diff --git a/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart b/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
index afd418a..9c8d78d 100644
--- a/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
@@ -295,6 +295,36 @@
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Template<
     Message Function(
+        String string,
+        String
+            string2)> templateBinaryOperatorWrittenOut = const Template<
+        Message Function(String string, String string2)>(
+    messageTemplate:
+        r"""Binary operator '#string' is written as '#string2' instead of the written out word.""",
+    tipTemplate: r"""Try replacing '#string' with '#string2'.""",
+    withArguments: _withArgumentsBinaryOperatorWrittenOut);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(String string, String string2)>
+    codeBinaryOperatorWrittenOut =
+    const Code<Message Function(String string, String string2)>(
+        "BinaryOperatorWrittenOut", templateBinaryOperatorWrittenOut,
+        index: 112);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsBinaryOperatorWrittenOut(String string, String string2) {
+  if (string.isEmpty) throw 'No string provided';
+  if (string2.isEmpty) throw 'No string provided';
+  return new Message(codeBinaryOperatorWrittenOut,
+      message:
+          """Binary operator '${string}' is written as '${string2}' instead of the written out word.""",
+      tip: """Try replacing '${string}' with '${string2}'.""",
+      arguments: {'string': string, 'string2': string2});
+}
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<
+    Message Function(
         String name,
         String
             name2)> templateBoundIssueViaCycleNonSimplicity = const Template<
diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart b/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart
index 09d8ad1..f7a1317 100644
--- a/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart
@@ -4615,13 +4615,22 @@
       token = typeArg.parseArguments(bangToken, this);
       assert(optional('(', token.next));
     }
+
+    return _parsePrecedenceExpressionLoop(
+        precedence, allowCascades, typeArg, token);
+  }
+
+  Token _parsePrecedenceExpressionLoop(int precedence, bool allowCascades,
+      TypeParamOrArgInfo typeArg, Token token) {
     Token next = token.next;
     TokenType type = next.type;
     int tokenLevel = _computePrecedence(next);
+    bool enteredLoop = false;
     for (int level = tokenLevel; level >= precedence; --level) {
       int lastBinaryExpressionLevel = -1;
       Token lastCascade;
       while (identical(tokenLevel, level)) {
+        enteredLoop = true;
         Token operator = next;
         if (identical(tokenLevel, CASCADE_PRECEDENCE)) {
           if (!allowCascades) {
@@ -4725,10 +4734,103 @@
         type = next.type;
         tokenLevel = _computePrecedence(next);
       }
+      if (_recoverAtPrecedenceLevel && !_currentlyRecovering) {
+        // Attempt recovery
+        if (_attemptPrecedenceLevelRecovery(
+            token, precedence, level, allowCascades, typeArg)) {
+          // Recovered - try again at same level with the replacement token.
+          level++;
+          next = token.next;
+          type = next.type;
+          tokenLevel = _computePrecedence(next);
+        }
+      }
+    }
+
+    if (!enteredLoop && _recoverAtPrecedenceLevel && !_currentlyRecovering) {
+      // Attempt recovery
+      if (_attemptPrecedenceLevelRecovery(
+          token, precedence, /*currentLevel = */ -1, allowCascades, typeArg)) {
+        return _parsePrecedenceExpressionLoop(
+            precedence, allowCascades, typeArg, token);
+      }
     }
     return token;
   }
 
+  /// Attempt a recovery where [token.next] is replaced.
+  bool _attemptPrecedenceLevelRecovery(Token token, int precedence,
+      int currentLevel, bool allowCascades, TypeParamOrArgInfo typeArg) {
+    // Attempt recovery.
+    assert(_token_recovery_replacements.containsKey(token.next.lexeme));
+    TokenType replacement = _token_recovery_replacements[token.next.lexeme];
+    if (currentLevel >= 0) {
+      // Check that the new precedence and currentLevel would have accepted this
+      // replacement here.
+      int newLevel = replacement.precedence;
+      // The loop it would normally have gone through is something like
+      // for (; ; --level) {
+      //   while (identical(tokenLevel, level)) {
+      //   }
+      // }
+      // So if the new tokens level <= the "old" (current) level, [level] (in
+      // the above code snippet) would get down to it and accept it.
+      // But if the new tokens level > the "old" (current) level, normally we
+      // would never get to it - so we shouldn't here either. As the loop starts
+      // by taking the first tokens tokenLevel as level, recursing below won't
+      // weed that out so we need to do it here.
+      if (newLevel > currentLevel) return false;
+    }
+
+    _currentlyRecovering = true;
+    _recoverAtPrecedenceLevel = false;
+    Listener originalListener = listener;
+    TokenStreamRewriter originalRewriter = cachedRewriter;
+    NullListener nullListener = listener = new NullListener();
+    UndoableTokenStreamRewriter undoableTokenStreamRewriter =
+        new UndoableTokenStreamRewriter();
+    cachedRewriter = undoableTokenStreamRewriter;
+    rewriter.replaceNextTokenWithSyntheticToken(token, replacement);
+    bool acceptRecovery = false;
+    Token afterExpression = _parsePrecedenceExpressionLoop(
+        precedence, allowCascades, typeArg, token);
+
+    if (!nullListener.hasErrors &&
+        isOneOfOrEof(afterExpression.next, const [';', ',', ')', '{', '}'])) {
+      // Seems good!
+      acceptRecovery = true;
+    }
+
+    // Undo all changes and reset.
+    _currentlyRecovering = false;
+    undoableTokenStreamRewriter.undo();
+    listener = originalListener;
+    cachedRewriter = originalRewriter;
+
+    if (acceptRecovery) {
+      // Report and redo recovery.
+      reportRecoverableError(
+          token.next,
+          codes.templateBinaryOperatorWrittenOut
+              .withArguments(token.next.lexeme, replacement.lexeme));
+      rewriter.replaceNextTokenWithSyntheticToken(token, replacement);
+      return true;
+    }
+    return false;
+  }
+
+  bool _recoverAtPrecedenceLevel = false;
+  bool _currentlyRecovering = false;
+  static const Map<String, TokenType> _token_recovery_replacements = const {
+    // E.g. in Kotlin these are written out, see.
+    // https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/.
+    "xor": TokenType.CARET,
+    "and": TokenType.AMPERSAND,
+    "or": TokenType.BAR,
+    "shl": TokenType.LT_LT,
+    "shr": TokenType.GT_GT,
+  };
+
   int _computePrecedence(Token token) {
     TokenType type = token.type;
     if (identical(type, TokenType.BANG)) {
@@ -4751,7 +4853,15 @@
       if (!isConditional) {
         return SELECTOR_PRECEDENCE;
       }
+    } else if (identical(type, TokenType.IDENTIFIER)) {
+      // An identifier at this point is not right. So some recovery is going to
+      // happen soon. The question is, if we can do a better recovery here.
+      if (!_currentlyRecovering &&
+          _token_recovery_replacements.containsKey(token.lexeme)) {
+        _recoverAtPrecedenceLevel = true;
+      }
     }
+
     return type.precedence;
   }
 
diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/token_stream_rewriter.dart b/pkg/_fe_analyzer_shared/lib/src/parser/token_stream_rewriter.dart
index cc5cbce..c3e261a 100644
--- a/pkg/_fe_analyzer_shared/lib/src/parser/token_stream_rewriter.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/parser/token_stream_rewriter.dart
@@ -9,6 +9,7 @@
         BeginToken,
         CommentToken,
         Keyword,
+        ReplacementToken,
         SimpleToken,
         SyntheticBeginToken,
         SyntheticKeywordToken,
@@ -113,6 +114,27 @@
     return current;
   }
 
+  /// Insert a new simple synthetic token of [newTokenType] after
+  /// [previousToken] instead of the token actually coming after it and return
+  /// the new token.
+  /// The old token will be linked from the new one though, so it's not totally
+  /// gone.
+  ReplacementToken replaceNextTokenWithSyntheticToken(
+      Token previousToken, TokenType newTokenType) {
+    assert(newTokenType is! Keyword,
+        'use an unwritten variation of insertSyntheticKeyword instead');
+
+    // [token] <--> [a] <--> [b]
+    ReplacementToken replacement =
+        new ReplacementToken(newTokenType, previousToken.next);
+    insertToken(previousToken, replacement);
+    // [token] <--> [replacement] <--> [a] <--> [b]
+    _setNext(replacement, replacement.next.next);
+    // [token] <--> [replacement] <--> [b]
+
+    return replacement;
+  }
+
   Token _setNext(Token setOn, Token nextToken);
   void _setEndGroup(BeginToken setOn, Token endGroup);
   void _setOffset(Token setOn, int offset);
@@ -248,6 +270,12 @@
   void _setPrevious(Token setOn, Token previous) {
     throw new UnimplementedError("_setPrevious");
   }
+
+  @override
+  ReplacementToken replaceNextTokenWithSyntheticToken(
+      Token previousToken, TokenType newTokenType) {
+    throw new UnimplementedError("replaceWithSyntheticToken");
+  }
 }
 
 mixin _TokenStreamMixin {
diff --git a/pkg/_fe_analyzer_shared/lib/src/scanner/token.dart b/pkg/_fe_analyzer_shared/lib/src/scanner/token.dart
index 9f501af..38f0335 100644
--- a/pkg/_fe_analyzer_shared/lib/src/scanner/token.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/scanner/token.dart
@@ -804,6 +804,32 @@
   Token copy() => new SyntheticToken(type, offset);
 }
 
+/// A token used to replace another token in the stream, while still keeping the
+/// old token around (in [replacedToken]). Automatically sets the offset and
+/// precedingComments from the data available on [replacedToken].
+class ReplacementToken extends SyntheticToken {
+  /// The token that this token replaces. This will normally be the token
+  /// representing what the user actually wrote.
+  final Token replacedToken;
+
+  ReplacementToken(TokenType type, this.replacedToken)
+      : super(type, replacedToken.offset) {
+    precedingComments = replacedToken.precedingComments;
+  }
+
+  @override
+  Token beforeSynthetic;
+
+  @override
+  bool get isSynthetic => true;
+
+  @override
+  int get length => 0;
+
+  @override
+  Token copy() => new ReplacementToken(type, replacedToken);
+}
+
 /**
  * A token that was scanned from the input. Each token knows which tokens
  * precede and follow it, acting as a link in a doubly linked list of tokens.
diff --git a/pkg/analyzer/lib/error/error.dart b/pkg/analyzer/lib/error/error.dart
index 5d9f60a..0d443de 100644
--- a/pkg/analyzer/lib/error/error.dart
+++ b/pkg/analyzer/lib/error/error.dart
@@ -597,6 +597,7 @@
   ParserErrorCode.ANNOTATION_ON_TYPE_ARGUMENT,
   ParserErrorCode.ANNOTATION_WITH_TYPE_ARGUMENTS,
   ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER,
+  ParserErrorCode.BINARY_OPERATOR_WRITTEN_OUT,
   ParserErrorCode.BREAK_OUTSIDE_OF_LOOP,
   ParserErrorCode.CATCH_SYNTAX,
   ParserErrorCode.CATCH_SYNTAX_EXTRA_PARAMETERS,
diff --git a/pkg/analyzer/lib/src/dart/error/syntactic_errors.dart b/pkg/analyzer/lib/src/dart/error/syntactic_errors.dart
index adc7492..f9dd391 100644
--- a/pkg/analyzer/lib/src/dart/error/syntactic_errors.dart
+++ b/pkg/analyzer/lib/src/dart/error/syntactic_errors.dart
@@ -72,6 +72,9 @@
           "The keywords 'await' and 'yield' can't be used as "
               "identifiers in an asynchronous or generator function.");
 
+  static const ParserErrorCode BINARY_OPERATOR_WRITTEN_OUT =
+      _BINARY_OPERATOR_WRITTEN_OUT;
+
   static const ParserErrorCode BREAK_OUTSIDE_OF_LOOP = _BREAK_OUTSIDE_OF_LOOP;
 
   static const ParserErrorCode CATCH_SYNTAX = _CATCH_SYNTAX;
diff --git a/pkg/analyzer/lib/src/dart/error/syntactic_errors.g.dart b/pkg/analyzer/lib/src/dart/error/syntactic_errors.g.dart
index 0698c8b..be1de3a 100644
--- a/pkg/analyzer/lib/src/dart/error/syntactic_errors.g.dart
+++ b/pkg/analyzer/lib/src/dart/error/syntactic_errors.g.dart
@@ -119,6 +119,7 @@
   _EXTERNAL_LATE_FIELD,
   _ABSTRACT_EXTERNAL_FIELD,
   _ANNOTATION_ON_TYPE_ARGUMENT,
+  _BINARY_OPERATOR_WRITTEN_OUT,
 ];
 
 const ParserErrorCode _ABSTRACT_CLASS_MEMBER = ParserErrorCode(
@@ -148,6 +149,11 @@
     'ANNOTATION_WITH_TYPE_ARGUMENTS',
     r"An annotation (metadata) can't use type arguments.");
 
+const ParserErrorCode _BINARY_OPERATOR_WRITTEN_OUT = ParserErrorCode(
+    'BINARY_OPERATOR_WRITTEN_OUT',
+    r"Binary operator '#string' is written as '#string2' instead of the written out word.",
+    correction: "Try replacing '#string' with '#string2'.");
+
 const ParserErrorCode _BREAK_OUTSIDE_OF_LOOP = ParserErrorCode(
     'BREAK_OUTSIDE_OF_LOOP',
     r"A break statement can't be used outside of a loop or switch statement.",
diff --git a/pkg/analyzer/test/generated/parser_fasta_test.dart b/pkg/analyzer/test/generated/parser_fasta_test.dart
index fa9fb23..e4b80d0 100644
--- a/pkg/analyzer/test/generated/parser_fasta_test.dart
+++ b/pkg/analyzer/test/generated/parser_fasta_test.dart
@@ -1114,6 +1114,17 @@
 @reflectiveTest
 class ComplexParserTest_Fasta extends FastaParserTestCase
     with ComplexParserTestMixin {
+  void test_binary_operator_written_out_expression() {
+    BinaryExpression expression = parseExpression('x xor y', errors: [
+      expectedError(ParserErrorCode.BINARY_OPERATOR_WRITTEN_OUT, 2, 3),
+    ]);
+    SimpleIdentifier lhs = expression.leftOperand;
+    expect(lhs.name, 'x');
+    expect(expression.operator.lexeme, '^');
+    SimpleIdentifier rhs = expression.rightOperand;
+    expect(rhs.name, 'y');
+  }
+
   void test_conditionalExpression_precedence_nullableType_as2() {
     ExpressionStatement statement = parseStatement('x as bool? ? (x + y) : z;');
     ConditionalExpression expression = statement.expression;
diff --git a/pkg/analyzer/test/src/diagnostics/binary_operator_written_out_test.dart b/pkg/analyzer/test/src/diagnostics/binary_operator_written_out_test.dart
new file mode 100644
index 0000000..a669585
--- /dev/null
+++ b/pkg/analyzer/test/src/diagnostics/binary_operator_written_out_test.dart
@@ -0,0 +1,107 @@
+// Copyright (c) 2020, 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.
+
+import 'package:analyzer/src/dart/error/syntactic_errors.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../dart/resolution/context_collection_resolution.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(BinaryOperatorWrittenOutTest);
+  });
+}
+
+@reflectiveTest
+class BinaryOperatorWrittenOutTest extends PubPackageResolutionTest {
+  test_using_and() async {
+    await assertErrorsInCode(r'''
+f(var x, var y) {
+  return x and y;
+}
+''', [
+      error(ParserErrorCode.BINARY_OPERATOR_WRITTEN_OUT, 29, 3),
+    ]);
+  }
+
+  test_using_and_no_error() async {
+    await assertErrorsInCode(r'''
+f(var x, var y) {
+  return x & y;
+}
+''', []);
+  }
+
+  test_using_or() async {
+    await assertErrorsInCode(r'''
+f(var x, var y) {
+  return x or y;
+}
+''', [
+      error(ParserErrorCode.BINARY_OPERATOR_WRITTEN_OUT, 29, 2),
+    ]);
+  }
+
+  test_using_or_no_error() async {
+    await assertErrorsInCode(r'''
+f(var x, var y) {
+  return x | y;
+}
+''', []);
+  }
+
+  test_using_shl() async {
+    await assertErrorsInCode(r'''
+f(var x) {
+  return x shl 2;
+}
+''', [
+      error(ParserErrorCode.BINARY_OPERATOR_WRITTEN_OUT, 22, 3),
+    ]);
+  }
+
+  test_using_shl_no_error() async {
+    await assertErrorsInCode(r'''
+f(var x) {
+  return x << 2;
+}
+''', []);
+  }
+
+  test_using_shr() async {
+    await assertErrorsInCode(r'''
+f(var x) {
+  return x shr 2;
+}
+''', [
+      error(ParserErrorCode.BINARY_OPERATOR_WRITTEN_OUT, 22, 3),
+    ]);
+  }
+
+  test_using_shr_no_error() async {
+    await assertErrorsInCode(r'''
+f(var x) {
+  return x >> 2;
+}
+''', []);
+  }
+
+  test_using_xor() async {
+    await assertErrorsInCode(r'''
+f(var x, var y) {
+  return x xor y;
+}
+''', [
+      error(ParserErrorCode.BINARY_OPERATOR_WRITTEN_OUT, 29, 3),
+    ]);
+  }
+
+  test_using_xor_no_error() async {
+    await assertErrorsInCode(r'''
+f(var x, var y) {
+  return x ^ y;
+}
+''', []);
+  }
+}
diff --git a/pkg/analyzer/test/src/diagnostics/test_all.dart b/pkg/analyzer/test/src/diagnostics/test_all.dart
index 94870ce..57f747d 100644
--- a/pkg/analyzer/test/src/diagnostics/test_all.dart
+++ b/pkg/analyzer/test/src/diagnostics/test_all.dart
@@ -37,6 +37,7 @@
 import 'await_in_late_local_variable_initializer_test.dart'
     as await_in_late_local_variable_initializer;
 import 'await_in_wrong_context_test.dart' as await_in_wrong_context;
+import 'binary_operator_written_out_test.dart' as binary_operator_written_out;
 import 'body_might_complete_normally_test.dart' as body_might_complete_normally;
 import 'built_in_identifier_as_extension_name_test.dart'
     as built_in_as_extension_name;
@@ -668,6 +669,7 @@
     async_keyword_used_as_identifier.main();
     await_in_late_local_variable_initializer.main();
     await_in_wrong_context.main();
+    binary_operator_written_out.main();
     body_might_complete_normally.main();
     built_in_as_extension_name.main();
     built_in_as_prefix_name.main();
diff --git a/pkg/front_end/messages.yaml b/pkg/front_end/messages.yaml
index d568f05..618e1fb 100644
--- a/pkg/front_end/messages.yaml
+++ b/pkg/front_end/messages.yaml
@@ -3061,6 +3061,14 @@
   tip: "Try replacing the colon with the keyword 'in'."
   analyzerCode: ParserErrorCode.COLON_IN_PLACE_OF_IN
 
+BinaryOperatorWrittenOut:
+  index: 112
+  template: "Binary operator '#string' is written as '#string2' instead of the written out word."
+  tip: "Try replacing '#string' with '#string2'."
+  analyzerCode: ParserErrorCode.BINARY_OPERATOR_WRITTEN_OUT
+  script: >
+    int foo(int x, int y) => x xor y;
+
 ExternalFactoryRedirection:
   index: 85
   template: "A redirecting factory can't be external."
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart b/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart
new file mode 100644
index 0000000..f65a3e9
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart
@@ -0,0 +1,41 @@
+abstract class Key {
+  int get a => runtimeType.hashCode xor null.hashCode;
+  int get b => runtimeType.hashCode ^ null.hashCode;
+  int get c { return runtimeType.hashCode xor null.hashCode; }
+  int get d { return runtimeType.hashCode ^ null.hashCode; }
+
+  int get e => 1 + runtimeType.hashCode xor null.hashCode + 3;
+  int get f => 1 + runtimeType.hashCode ^ null.hashCode + 3;
+  int get g { return 1 + runtimeType.hashCode xor null.hashCode + 3; }
+  int get h { return 1 + runtimeType.hashCode ^ null.hashCode + 3; }
+
+  int i(int x, int y) => x xor y;
+  int j(int x, int y) => x ^ y;
+  int k(int x, int y) { return x xor y; }
+  int l(int x, int y) { return x ^ y; }
+  int m(int x, int y) { int z =  x xor y; return z; }
+  int n(int x, int y) { int z = x ^ y; return z; }
+
+  int o(int x, int y) => 1 + x xor y + 3;
+  int p(int x, int y) => 1 + x ^ y + 3;
+  int q(int x, int y) { return 1 + x xor y + 3; }
+  int r(int x, int y) { return 1 + x ^ y + 3; }
+
+  s(int x, int y) {
+    s(x xor y, x xor y);
+    s(x ^ y, x ^ y);
+  }
+
+  Key(int x, int y) : foo = x xor y, bar = x xor y {
+    print("hello ${x xor y}");
+  }
+
+  Key(int x, int y) : foo = x ^ y, bar = x ^ y {
+    print("hello ${x ^ y}");
+  }
+
+  not_currently_working(int x, int y) {
+    x xor y;
+    x ^ y;
+  }
+}
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.expect
new file mode 100644
index 0000000..9eb58d9
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.expect
@@ -0,0 +1,1221 @@
+Problems reported:
+
+parser/error_recovery/issue_26810:2:37: Binary operator 'xor' is written as '^' instead of the written out word.
+  int get a => runtimeType.hashCode xor null.hashCode;
+                                    ^^^
+
+parser/error_recovery/issue_26810:4:43: Binary operator 'xor' is written as '^' instead of the written out word.
+  int get c { return runtimeType.hashCode xor null.hashCode; }
+                                          ^^^
+
+parser/error_recovery/issue_26810:7:41: Binary operator 'xor' is written as '^' instead of the written out word.
+  int get e => 1 + runtimeType.hashCode xor null.hashCode + 3;
+                                        ^^^
+
+parser/error_recovery/issue_26810:9:47: Binary operator 'xor' is written as '^' instead of the written out word.
+  int get g { return 1 + runtimeType.hashCode xor null.hashCode + 3; }
+                                              ^^^
+
+parser/error_recovery/issue_26810:12:28: Binary operator 'xor' is written as '^' instead of the written out word.
+  int i(int x, int y) => x xor y;
+                           ^^^
+
+parser/error_recovery/issue_26810:14:34: Binary operator 'xor' is written as '^' instead of the written out word.
+  int k(int x, int y) { return x xor y; }
+                                 ^^^
+
+parser/error_recovery/issue_26810:16:36: Binary operator 'xor' is written as '^' instead of the written out word.
+  int m(int x, int y) { int z =  x xor y; return z; }
+                                   ^^^
+
+parser/error_recovery/issue_26810:19:32: Binary operator 'xor' is written as '^' instead of the written out word.
+  int o(int x, int y) => 1 + x xor y + 3;
+                               ^^^
+
+parser/error_recovery/issue_26810:21:38: Binary operator 'xor' is written as '^' instead of the written out word.
+  int q(int x, int y) { return 1 + x xor y + 3; }
+                                     ^^^
+
+parser/error_recovery/issue_26810:25:9: Binary operator 'xor' is written as '^' instead of the written out word.
+    s(x xor y, x xor y);
+        ^^^
+
+parser/error_recovery/issue_26810:25:18: Binary operator 'xor' is written as '^' instead of the written out word.
+    s(x xor y, x xor y);
+                 ^^^
+
+parser/error_recovery/issue_26810:29:31: Binary operator 'xor' is written as '^' instead of the written out word.
+  Key(int x, int y) : foo = x xor y, bar = x xor y {
+                              ^^^
+
+parser/error_recovery/issue_26810:29:46: Binary operator 'xor' is written as '^' instead of the written out word.
+  Key(int x, int y) : foo = x xor y, bar = x xor y {
+                                             ^^^
+
+parser/error_recovery/issue_26810:30:22: Binary operator 'xor' is written as '^' instead of the written out word.
+    print("hello ${x xor y}");
+                     ^^^
+
+parser/error_recovery/issue_26810:38:7: Expected ';' after this.
+    x xor y;
+      ^^^
+
+beginCompilationUnit(abstract)
+  beginMetadataStar(abstract)
+  endMetadataStar(0)
+  beginClassOrNamedMixinApplicationPrelude(abstract)
+    handleIdentifier(Key, classOrMixinDeclaration)
+    handleNoTypeVariables({)
+    beginClassDeclaration(abstract, abstract, Key)
+      handleNoType(Key)
+      handleClassExtends(null, 1)
+      handleClassNoWithClause()
+      handleClassOrMixinImplements(null, 0)
+      handleClassHeader(abstract, class, null)
+      beginClassOrMixinBody(DeclarationKind.Class, {)
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, a)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(a, methodDeclaration)
+            handleNoTypeVariables(=>)
+            handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleIdentifier(runtimeType, expression)
+            handleNoTypeArguments(.)
+            handleNoArguments(.)
+            handleSend(runtimeType, .)
+            handleIdentifier(hashCode, expressionContinuation)
+            handleNoTypeArguments(xor)
+            handleNoArguments(xor)
+            handleSend(hashCode, xor)
+            handleEndingBinaryExpression(.)
+            handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+            beginBinaryExpression(^)
+              handleLiteralNull(null)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(hashCode, ;)
+              handleEndingBinaryExpression(.)
+            endBinaryExpression(^)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(get, int, =>, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, b)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(b, methodDeclaration)
+            handleNoTypeVariables(=>)
+            handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleIdentifier(runtimeType, expression)
+            handleNoTypeArguments(.)
+            handleNoArguments(.)
+            handleSend(runtimeType, .)
+            handleIdentifier(hashCode, expressionContinuation)
+            handleNoTypeArguments(^)
+            handleNoArguments(^)
+            handleSend(hashCode, ^)
+            handleEndingBinaryExpression(.)
+            beginBinaryExpression(^)
+              handleLiteralNull(null)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(hashCode, ;)
+              handleEndingBinaryExpression(.)
+            endBinaryExpression(^)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(get, int, =>, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, c)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(c, methodDeclaration)
+            handleNoTypeVariables({)
+            handleNoFormalParameters({, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleIdentifier(runtimeType, expression)
+                handleNoTypeArguments(.)
+                handleNoArguments(.)
+                handleSend(runtimeType, .)
+                handleIdentifier(hashCode, expressionContinuation)
+                handleNoTypeArguments(xor)
+                handleNoArguments(xor)
+                handleSend(hashCode, xor)
+                handleEndingBinaryExpression(.)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                beginBinaryExpression(^)
+                  handleLiteralNull(null)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(;)
+                  handleNoArguments(;)
+                  handleSend(hashCode, ;)
+                  handleEndingBinaryExpression(.)
+                endBinaryExpression(^)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(get, int, {, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, d)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(d, methodDeclaration)
+            handleNoTypeVariables({)
+            handleNoFormalParameters({, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleIdentifier(runtimeType, expression)
+                handleNoTypeArguments(.)
+                handleNoArguments(.)
+                handleSend(runtimeType, .)
+                handleIdentifier(hashCode, expressionContinuation)
+                handleNoTypeArguments(^)
+                handleNoArguments(^)
+                handleSend(hashCode, ^)
+                handleEndingBinaryExpression(.)
+                beginBinaryExpression(^)
+                  handleLiteralNull(null)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(;)
+                  handleNoArguments(;)
+                  handleSend(hashCode, ;)
+                  handleEndingBinaryExpression(.)
+                endBinaryExpression(^)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(get, int, {, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, e)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(e, methodDeclaration)
+            handleNoTypeVariables(=>)
+            handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleLiteralInt(1)
+            beginBinaryExpression(+)
+              handleIdentifier(runtimeType, expression)
+              handleNoTypeArguments(.)
+              handleNoArguments(.)
+              handleSend(runtimeType, .)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(xor)
+              handleNoArguments(xor)
+              handleSend(hashCode, xor)
+              handleEndingBinaryExpression(.)
+            endBinaryExpression(+)
+            handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+            beginBinaryExpression(^)
+              handleLiteralNull(null)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(+)
+              handleNoArguments(+)
+              handleSend(hashCode, +)
+              handleEndingBinaryExpression(.)
+              beginBinaryExpression(+)
+                handleLiteralInt(3)
+              endBinaryExpression(+)
+            endBinaryExpression(^)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(get, int, =>, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, f)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(f, methodDeclaration)
+            handleNoTypeVariables(=>)
+            handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleLiteralInt(1)
+            beginBinaryExpression(+)
+              handleIdentifier(runtimeType, expression)
+              handleNoTypeArguments(.)
+              handleNoArguments(.)
+              handleSend(runtimeType, .)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(^)
+              handleNoArguments(^)
+              handleSend(hashCode, ^)
+              handleEndingBinaryExpression(.)
+            endBinaryExpression(+)
+            beginBinaryExpression(^)
+              handleLiteralNull(null)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(+)
+              handleNoArguments(+)
+              handleSend(hashCode, +)
+              handleEndingBinaryExpression(.)
+              beginBinaryExpression(+)
+                handleLiteralInt(3)
+              endBinaryExpression(+)
+            endBinaryExpression(^)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(get, int, =>, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, g)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(g, methodDeclaration)
+            handleNoTypeVariables({)
+            handleNoFormalParameters({, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleLiteralInt(1)
+                beginBinaryExpression(+)
+                  handleIdentifier(runtimeType, expression)
+                  handleNoTypeArguments(.)
+                  handleNoArguments(.)
+                  handleSend(runtimeType, .)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(xor)
+                  handleNoArguments(xor)
+                  handleSend(hashCode, xor)
+                  handleEndingBinaryExpression(.)
+                endBinaryExpression(+)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                beginBinaryExpression(^)
+                  handleLiteralNull(null)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(+)
+                  handleNoArguments(+)
+                  handleSend(hashCode, +)
+                  handleEndingBinaryExpression(.)
+                  beginBinaryExpression(+)
+                    handleLiteralInt(3)
+                  endBinaryExpression(+)
+                endBinaryExpression(^)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(get, int, {, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, h)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(h, methodDeclaration)
+            handleNoTypeVariables({)
+            handleNoFormalParameters({, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleLiteralInt(1)
+                beginBinaryExpression(+)
+                  handleIdentifier(runtimeType, expression)
+                  handleNoTypeArguments(.)
+                  handleNoArguments(.)
+                  handleSend(runtimeType, .)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(^)
+                  handleNoArguments(^)
+                  handleSend(hashCode, ^)
+                  handleEndingBinaryExpression(.)
+                endBinaryExpression(+)
+                beginBinaryExpression(^)
+                  handleLiteralNull(null)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(+)
+                  handleNoArguments(+)
+                  handleSend(hashCode, +)
+                  handleEndingBinaryExpression(.)
+                  beginBinaryExpression(+)
+                    handleLiteralInt(3)
+                  endBinaryExpression(+)
+                endBinaryExpression(^)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(get, int, {, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, i)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(i)
+            handleType(int, null)
+            handleIdentifier(i, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleIdentifier(x, expression)
+            handleNoTypeArguments(xor)
+            handleNoArguments(xor)
+            handleSend(x, xor)
+            handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+            beginBinaryExpression(^)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(y, ;)
+            endBinaryExpression(^)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(null, int, (, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, j)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(j)
+            handleType(int, null)
+            handleIdentifier(j, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleIdentifier(x, expression)
+            handleNoTypeArguments(^)
+            handleNoArguments(^)
+            handleSend(x, ^)
+            beginBinaryExpression(^)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(y, ;)
+            endBinaryExpression(^)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(null, int, (, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, k)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(k)
+            handleType(int, null)
+            handleIdentifier(k, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(xor)
+                handleNoArguments(xor)
+                handleSend(x, xor)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                beginBinaryExpression(^)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(;)
+                  handleNoArguments(;)
+                  handleSend(y, ;)
+                endBinaryExpression(^)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, l)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(l)
+            handleType(int, null)
+            handleIdentifier(l, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(^)
+                handleNoArguments(^)
+                handleSend(x, ^)
+                beginBinaryExpression(^)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(;)
+                  handleNoArguments(;)
+                  handleSend(y, ;)
+                endBinaryExpression(^)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, m)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(m)
+            handleType(int, null)
+            handleIdentifier(m, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              handleIdentifier(int, typeReference)
+              handleNoTypeArguments(z)
+              handleType(int, null)
+              beginVariablesDeclaration(z, null, null)
+                handleIdentifier(z, localVariableDeclaration)
+                beginInitializedIdentifier(z)
+                  beginVariableInitializer(=)
+                    handleIdentifier(x, expression)
+                    handleNoTypeArguments(xor)
+                    handleNoArguments(xor)
+                    handleSend(x, xor)
+                    handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                    beginBinaryExpression(^)
+                      handleIdentifier(y, expression)
+                      handleNoTypeArguments(;)
+                      handleNoArguments(;)
+                      handleSend(y, ;)
+                    endBinaryExpression(^)
+                  endVariableInitializer(=)
+                endInitializedIdentifier(z)
+              endVariablesDeclaration(1, ;)
+              beginReturnStatement(return)
+                handleIdentifier(z, expression)
+                handleNoTypeArguments(;)
+                handleNoArguments(;)
+                handleSend(z, ;)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(2, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, n)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(n)
+            handleType(int, null)
+            handleIdentifier(n, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              handleIdentifier(int, typeReference)
+              handleNoTypeArguments(z)
+              handleType(int, null)
+              beginVariablesDeclaration(z, null, null)
+                handleIdentifier(z, localVariableDeclaration)
+                beginInitializedIdentifier(z)
+                  beginVariableInitializer(=)
+                    handleIdentifier(x, expression)
+                    handleNoTypeArguments(^)
+                    handleNoArguments(^)
+                    handleSend(x, ^)
+                    beginBinaryExpression(^)
+                      handleIdentifier(y, expression)
+                      handleNoTypeArguments(;)
+                      handleNoArguments(;)
+                      handleSend(y, ;)
+                    endBinaryExpression(^)
+                  endVariableInitializer(=)
+                endInitializedIdentifier(z)
+              endVariablesDeclaration(1, ;)
+              beginReturnStatement(return)
+                handleIdentifier(z, expression)
+                handleNoTypeArguments(;)
+                handleNoArguments(;)
+                handleSend(z, ;)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(2, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, o)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(o)
+            handleType(int, null)
+            handleIdentifier(o, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleLiteralInt(1)
+            beginBinaryExpression(+)
+              handleIdentifier(x, expression)
+              handleNoTypeArguments(xor)
+              handleNoArguments(xor)
+              handleSend(x, xor)
+            endBinaryExpression(+)
+            handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+            beginBinaryExpression(^)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments(+)
+              handleNoArguments(+)
+              handleSend(y, +)
+              beginBinaryExpression(+)
+                handleLiteralInt(3)
+              endBinaryExpression(+)
+            endBinaryExpression(^)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(null, int, (, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, p)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(p)
+            handleType(int, null)
+            handleIdentifier(p, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleLiteralInt(1)
+            beginBinaryExpression(+)
+              handleIdentifier(x, expression)
+              handleNoTypeArguments(^)
+              handleNoArguments(^)
+              handleSend(x, ^)
+            endBinaryExpression(+)
+            beginBinaryExpression(^)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments(+)
+              handleNoArguments(+)
+              handleSend(y, +)
+              beginBinaryExpression(+)
+                handleLiteralInt(3)
+              endBinaryExpression(+)
+            endBinaryExpression(^)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(null, int, (, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, q)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(q)
+            handleType(int, null)
+            handleIdentifier(q, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleLiteralInt(1)
+                beginBinaryExpression(+)
+                  handleIdentifier(x, expression)
+                  handleNoTypeArguments(xor)
+                  handleNoArguments(xor)
+                  handleSend(x, xor)
+                endBinaryExpression(+)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                beginBinaryExpression(^)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(+)
+                  handleNoArguments(+)
+                  handleSend(y, +)
+                  beginBinaryExpression(+)
+                    handleLiteralInt(3)
+                  endBinaryExpression(+)
+                endBinaryExpression(^)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, r)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(r)
+            handleType(int, null)
+            handleIdentifier(r, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleLiteralInt(1)
+                beginBinaryExpression(+)
+                  handleIdentifier(x, expression)
+                  handleNoTypeArguments(^)
+                  handleNoArguments(^)
+                  handleSend(x, ^)
+                endBinaryExpression(+)
+                beginBinaryExpression(^)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(+)
+                  handleNoArguments(+)
+                  handleSend(y, +)
+                  beginBinaryExpression(+)
+                    handleLiteralInt(3)
+                  endBinaryExpression(+)
+                endBinaryExpression(^)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(s)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, s)
+            handleNoType(})
+            handleIdentifier(s, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              handleIdentifier(s, expression)
+              handleNoTypeArguments(()
+              beginArguments(()
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(xor)
+                handleNoArguments(xor)
+                handleSend(x, xor)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                beginBinaryExpression(^)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(,)
+                  handleNoArguments(,)
+                  handleSend(y, ,)
+                endBinaryExpression(^)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(xor)
+                handleNoArguments(xor)
+                handleSend(x, xor)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                beginBinaryExpression(^)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments())
+                  handleNoArguments())
+                  handleSend(y, ))
+                endBinaryExpression(^)
+              endArguments(2, (, ))
+              handleSend(s, ;)
+              handleExpressionStatement(;)
+              handleIdentifier(s, expression)
+              handleNoTypeArguments(()
+              beginArguments(()
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(^)
+                handleNoArguments(^)
+                handleSend(x, ^)
+                beginBinaryExpression(^)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(,)
+                  handleNoArguments(,)
+                  handleSend(y, ,)
+                endBinaryExpression(^)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(^)
+                handleNoArguments(^)
+                handleSend(x, ^)
+                beginBinaryExpression(^)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments())
+                  handleNoArguments())
+                  handleSend(y, ))
+                endBinaryExpression(^)
+              endArguments(2, (, ))
+              handleSend(s, ;)
+              handleExpressionStatement(;)
+            endBlockFunctionBody(2, {, })
+          endClassMethod(null, s, (, null, })
+        endMember()
+        beginMetadataStar(Key)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, Key)
+            handleNoType(})
+            handleIdentifier(Key, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            beginInitializers(:)
+              beginInitializer(foo)
+                handleIdentifier(foo, expression)
+                handleNoTypeArguments(=)
+                handleNoArguments(=)
+                handleSend(foo, =)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(xor)
+                handleNoArguments(xor)
+                handleSend(x, xor)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                beginBinaryExpression(^)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(,)
+                  handleNoArguments(,)
+                  handleSend(y, ,)
+                endBinaryExpression(^)
+                handleAssignmentExpression(=)
+              endInitializer(,)
+              beginInitializer(bar)
+                handleIdentifier(bar, expression)
+                handleNoTypeArguments(=)
+                handleNoArguments(=)
+                handleSend(bar, =)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(xor)
+                handleNoArguments(xor)
+                handleSend(x, xor)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                beginBinaryExpression(^)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments({)
+                  handleNoArguments({)
+                  handleSend(y, {)
+                endBinaryExpression(^)
+                handleAssignmentExpression(=)
+              endInitializer({)
+            endInitializers(2, :, {)
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              handleIdentifier(print, expression)
+              handleNoTypeArguments(()
+              beginArguments(()
+                beginLiteralString("hello )
+                  handleIdentifier(x, expression)
+                  handleNoTypeArguments(xor)
+                  handleNoArguments(xor)
+                  handleSend(x, xor)
+                  handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                  beginBinaryExpression(^)
+                    handleIdentifier(y, expression)
+                    handleNoTypeArguments(})
+                    handleNoArguments(})
+                    handleSend(y, })
+                  endBinaryExpression(^)
+                  handleInterpolationExpression(${, })
+                  handleStringPart(")
+                endLiteralString(1, ))
+              endArguments(1, (, ))
+              handleSend(print, ;)
+              handleExpressionStatement(;)
+            endBlockFunctionBody(1, {, })
+          endClassConstructor(null, Key, (, :, })
+        endMember()
+        beginMetadataStar(Key)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, Key)
+            handleNoType(})
+            handleIdentifier(Key, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            beginInitializers(:)
+              beginInitializer(foo)
+                handleIdentifier(foo, expression)
+                handleNoTypeArguments(=)
+                handleNoArguments(=)
+                handleSend(foo, =)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(^)
+                handleNoArguments(^)
+                handleSend(x, ^)
+                beginBinaryExpression(^)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(,)
+                  handleNoArguments(,)
+                  handleSend(y, ,)
+                endBinaryExpression(^)
+                handleAssignmentExpression(=)
+              endInitializer(,)
+              beginInitializer(bar)
+                handleIdentifier(bar, expression)
+                handleNoTypeArguments(=)
+                handleNoArguments(=)
+                handleSend(bar, =)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(^)
+                handleNoArguments(^)
+                handleSend(x, ^)
+                beginBinaryExpression(^)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments({)
+                  handleNoArguments({)
+                  handleSend(y, {)
+                endBinaryExpression(^)
+                handleAssignmentExpression(=)
+              endInitializer({)
+            endInitializers(2, :, {)
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              handleIdentifier(print, expression)
+              handleNoTypeArguments(()
+              beginArguments(()
+                beginLiteralString("hello )
+                  handleIdentifier(x, expression)
+                  handleNoTypeArguments(^)
+                  handleNoArguments(^)
+                  handleSend(x, ^)
+                  beginBinaryExpression(^)
+                    handleIdentifier(y, expression)
+                    handleNoTypeArguments(})
+                    handleNoArguments(})
+                    handleSend(y, })
+                  endBinaryExpression(^)
+                  handleInterpolationExpression(${, })
+                  handleStringPart(")
+                endLiteralString(1, ))
+              endArguments(1, (, ))
+              handleSend(print, ;)
+              handleExpressionStatement(;)
+            endBlockFunctionBody(1, {, })
+          endClassConstructor(null, Key, (, :, })
+        endMember()
+        beginMetadataStar(not_currently_working)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, not_currently_working)
+            handleNoType(})
+            handleIdentifier(not_currently_working, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginMetadataStar(x)
+              endMetadataStar(0)
+              handleIdentifier(x, typeReference)
+              handleNoTypeArguments(xor)
+              handleType(x, null)
+              beginVariablesDeclaration(xor, null, null)
+                handleIdentifier(xor, localVariableDeclaration)
+                beginInitializedIdentifier(xor)
+                  handleNoVariableInitializer(xor)
+                endInitializedIdentifier(xor)
+                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], xor, xor)
+              endVariablesDeclaration(1, ;)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(y, ;)
+              handleExpressionStatement(;)
+              handleIdentifier(x, expression)
+              handleNoTypeArguments(^)
+              handleNoArguments(^)
+              handleSend(x, ^)
+              beginBinaryExpression(^)
+                handleIdentifier(y, expression)
+                handleNoTypeArguments(;)
+                handleNoArguments(;)
+                handleSend(y, ;)
+              endBinaryExpression(^)
+              handleExpressionStatement(;)
+            endBlockFunctionBody(3, {, })
+          endClassMethod(null, not_currently_working, (, null, })
+        endMember()
+      endClassOrMixinBody(DeclarationKind.Class, 22, {, })
+    endClassDeclaration(abstract, })
+  endTopLevelDeclaration()
+endCompilationUnit(1, )
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.intertwined.expect
new file mode 100644
index 0000000..b6c6fda
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.intertwined.expect
@@ -0,0 +1,2594 @@
+parseUnit(abstract)
+  skipErrorTokens(abstract)
+  listener: beginCompilationUnit(abstract)
+  syntheticPreviousToken(abstract)
+  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
+    parseMetadataStar()
+      listener: beginMetadataStar(abstract)
+      listener: endMetadataStar(0)
+    parseTopLevelKeywordDeclaration(, class, Instance of 'DirectiveContext')
+      parseClassDeclarationModifiers(, class)
+        parseTopLevelKeywordModifiers(abstract, class)
+      parseClassOrNamedMixinApplication(abstract, class)
+        listener: beginClassOrNamedMixinApplicationPrelude(abstract)
+        ensureIdentifier(class, classOrMixinDeclaration)
+          listener: handleIdentifier(Key, classOrMixinDeclaration)
+        listener: handleNoTypeVariables({)
+        listener: beginClassDeclaration(abstract, abstract, Key)
+        parseClass(Key, abstract, class, Key)
+          parseClassHeaderOpt(Key, abstract, class)
+            parseClassExtendsOpt(Key)
+              listener: handleNoType(Key)
+              listener: handleClassExtends(null, 1)
+            parseWithClauseOpt(Key)
+              listener: handleClassNoWithClause()
+            parseClassOrMixinImplementsOpt(Key)
+              listener: handleClassOrMixinImplements(null, 0)
+            listener: handleClassHeader(abstract, class, null)
+          parseClassOrMixinOrExtensionBody(Key, DeclarationKind.Class, Key)
+            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Key)
+              parseMetadataStar({)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod({, null, null, null, null, null, null, {, Instance of 'SimpleType', get, a, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, a)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(a, methodDeclaration)
+                parseQualifiedRestOpt(a, methodDeclarationContinuation)
+                listener: handleNoTypeVariables(=>)
+                parseGetterOrFormalParameters(a, a, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+                parseInitializersOpt(a)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(a)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(a, false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseSendOrFunctionLiteral(=>, expression)
+                              parseSend(=>, expression)
+                                ensureIdentifier(=>, expression)
+                                  listener: handleIdentifier(runtimeType, expression)
+                                listener: handleNoTypeArguments(.)
+                                parseArgumentsOpt(runtimeType)
+                                  listener: handleNoArguments(.)
+                                listener: handleSend(runtimeType, .)
+                        parsePrimary(., expressionContinuation)
+                          parseSendOrFunctionLiteral(., expressionContinuation)
+                            parseSend(., expressionContinuation)
+                              ensureIdentifier(., expressionContinuation)
+                                listener: handleIdentifier(hashCode, expressionContinuation)
+                              listener: handleNoTypeArguments(xor)
+                              parseArgumentsOpt(hashCode)
+                                listener: handleNoArguments(xor)
+                              listener: handleSend(hashCode, xor)
+                        listener: handleEndingBinaryExpression(.)
+                        rewriter()
+                        parsePrecedenceExpression(^, 11, true)
+                          parseUnaryExpression(^, true)
+                            parsePrimary(^, expression)
+                              parseLiteralNull(^)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                parseArgumentsOpt(hashCode)
+                        reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
+                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                        rewriter()
+                        listener: beginBinaryExpression(^)
+                        parsePrecedenceExpression(^, 11, true)
+                          parseUnaryExpression(^, true)
+                            parsePrimary(^, expression)
+                              parseLiteralNull(^)
+                                listener: handleLiteralNull(null)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(;)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(;)
+                                listener: handleSend(hashCode, ;)
+                          listener: handleEndingBinaryExpression(.)
+                        listener: endBinaryExpression(^)
+                    ensureSemicolon(hashCode)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(get, int, =>, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, b, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, b)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(b, methodDeclaration)
+                parseQualifiedRestOpt(b, methodDeclarationContinuation)
+                listener: handleNoTypeVariables(=>)
+                parseGetterOrFormalParameters(b, b, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+                parseInitializersOpt(b)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(b)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(b, false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseSendOrFunctionLiteral(=>, expression)
+                              parseSend(=>, expression)
+                                ensureIdentifier(=>, expression)
+                                  listener: handleIdentifier(runtimeType, expression)
+                                listener: handleNoTypeArguments(.)
+                                parseArgumentsOpt(runtimeType)
+                                  listener: handleNoArguments(.)
+                                listener: handleSend(runtimeType, .)
+                        parsePrimary(., expressionContinuation)
+                          parseSendOrFunctionLiteral(., expressionContinuation)
+                            parseSend(., expressionContinuation)
+                              ensureIdentifier(., expressionContinuation)
+                                listener: handleIdentifier(hashCode, expressionContinuation)
+                              listener: handleNoTypeArguments(^)
+                              parseArgumentsOpt(hashCode)
+                                listener: handleNoArguments(^)
+                              listener: handleSend(hashCode, ^)
+                        listener: handleEndingBinaryExpression(.)
+                        listener: beginBinaryExpression(^)
+                        parsePrecedenceExpression(^, 11, true)
+                          parseUnaryExpression(^, true)
+                            parsePrimary(^, expression)
+                              parseLiteralNull(^)
+                                listener: handleLiteralNull(null)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(;)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(;)
+                                listener: handleSend(hashCode, ;)
+                          listener: handleEndingBinaryExpression(.)
+                        listener: endBinaryExpression(^)
+                    ensureSemicolon(hashCode)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(get, int, =>, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, c, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, c)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(c, methodDeclaration)
+                parseQualifiedRestOpt(c, methodDeclarationContinuation)
+                listener: handleNoTypeVariables({)
+                parseGetterOrFormalParameters(c, c, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
+                parseInitializersOpt(c)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(c)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(c, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(runtimeType, expression)
+                                    listener: handleNoTypeArguments(.)
+                                    parseArgumentsOpt(runtimeType)
+                                      listener: handleNoArguments(.)
+                                    listener: handleSend(runtimeType, .)
+                            parsePrimary(., expressionContinuation)
+                              parseSendOrFunctionLiteral(., expressionContinuation)
+                                parseSend(., expressionContinuation)
+                                  ensureIdentifier(., expressionContinuation)
+                                    listener: handleIdentifier(hashCode, expressionContinuation)
+                                  listener: handleNoTypeArguments(xor)
+                                  parseArgumentsOpt(hashCode)
+                                    listener: handleNoArguments(xor)
+                                  listener: handleSend(hashCode, xor)
+                            listener: handleEndingBinaryExpression(.)
+                            rewriter()
+                            parsePrecedenceExpression(^, 11, true)
+                              parseUnaryExpression(^, true)
+                                parsePrimary(^, expression)
+                                  parseLiteralNull(^)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                    parseArgumentsOpt(hashCode)
+                            reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
+                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                            rewriter()
+                            listener: beginBinaryExpression(^)
+                            parsePrecedenceExpression(^, 11, true)
+                              parseUnaryExpression(^, true)
+                                parsePrimary(^, expression)
+                                  parseLiteralNull(^)
+                                    listener: handleLiteralNull(null)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(;)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(;)
+                                    listener: handleSend(hashCode, ;)
+                              listener: handleEndingBinaryExpression(.)
+                            listener: endBinaryExpression(^)
+                        ensureSemicolon(hashCode)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(get, int, {, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', get, d, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, d)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(d, methodDeclaration)
+                parseQualifiedRestOpt(d, methodDeclarationContinuation)
+                listener: handleNoTypeVariables({)
+                parseGetterOrFormalParameters(d, d, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
+                parseInitializersOpt(d)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(d)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(d, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(runtimeType, expression)
+                                    listener: handleNoTypeArguments(.)
+                                    parseArgumentsOpt(runtimeType)
+                                      listener: handleNoArguments(.)
+                                    listener: handleSend(runtimeType, .)
+                            parsePrimary(., expressionContinuation)
+                              parseSendOrFunctionLiteral(., expressionContinuation)
+                                parseSend(., expressionContinuation)
+                                  ensureIdentifier(., expressionContinuation)
+                                    listener: handleIdentifier(hashCode, expressionContinuation)
+                                  listener: handleNoTypeArguments(^)
+                                  parseArgumentsOpt(hashCode)
+                                    listener: handleNoArguments(^)
+                                  listener: handleSend(hashCode, ^)
+                            listener: handleEndingBinaryExpression(.)
+                            listener: beginBinaryExpression(^)
+                            parsePrecedenceExpression(^, 11, true)
+                              parseUnaryExpression(^, true)
+                                parsePrimary(^, expression)
+                                  parseLiteralNull(^)
+                                    listener: handleLiteralNull(null)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(;)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(;)
+                                    listener: handleSend(hashCode, ;)
+                              listener: handleEndingBinaryExpression(.)
+                            listener: endBinaryExpression(^)
+                        ensureSemicolon(hashCode)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(get, int, {, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', get, e, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, e)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(e, methodDeclaration)
+                parseQualifiedRestOpt(e, methodDeclarationContinuation)
+                listener: handleNoTypeVariables(=>)
+                parseGetterOrFormalParameters(e, e, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+                parseInitializersOpt(e)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(e)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(e, false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseLiteralInt(=>)
+                              listener: handleLiteralInt(1)
+                        listener: beginBinaryExpression(+)
+                        parsePrecedenceExpression(+, 14, true)
+                          parseUnaryExpression(+, true)
+                            parsePrimary(+, expression)
+                              parseSendOrFunctionLiteral(+, expression)
+                                parseSend(+, expression)
+                                  ensureIdentifier(+, expression)
+                                    listener: handleIdentifier(runtimeType, expression)
+                                  listener: handleNoTypeArguments(.)
+                                  parseArgumentsOpt(runtimeType)
+                                    listener: handleNoArguments(.)
+                                  listener: handleSend(runtimeType, .)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(xor)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(xor)
+                                listener: handleSend(hashCode, xor)
+                          listener: handleEndingBinaryExpression(.)
+                          rewriter()
+                        listener: endBinaryExpression(+)
+                        rewriter()
+                        parsePrecedenceExpression(^, 11, true)
+                          parseUnaryExpression(^, true)
+                            parsePrimary(^, expression)
+                              parseLiteralNull(^)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                parseArgumentsOpt(hashCode)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                        reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
+                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                        rewriter()
+                        listener: beginBinaryExpression(^)
+                        parsePrecedenceExpression(^, 11, true)
+                          parseUnaryExpression(^, true)
+                            parsePrimary(^, expression)
+                              parseLiteralNull(^)
+                                listener: handleLiteralNull(null)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(+)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(+)
+                                listener: handleSend(hashCode, +)
+                          listener: handleEndingBinaryExpression(.)
+                          listener: beginBinaryExpression(+)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                                  listener: handleLiteralInt(3)
+                          listener: endBinaryExpression(+)
+                        listener: endBinaryExpression(^)
+                    ensureSemicolon(3)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(get, int, =>, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, f, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, f)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(f, methodDeclaration)
+                parseQualifiedRestOpt(f, methodDeclarationContinuation)
+                listener: handleNoTypeVariables(=>)
+                parseGetterOrFormalParameters(f, f, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+                parseInitializersOpt(f)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(f)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(f, false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseLiteralInt(=>)
+                              listener: handleLiteralInt(1)
+                        listener: beginBinaryExpression(+)
+                        parsePrecedenceExpression(+, 14, true)
+                          parseUnaryExpression(+, true)
+                            parsePrimary(+, expression)
+                              parseSendOrFunctionLiteral(+, expression)
+                                parseSend(+, expression)
+                                  ensureIdentifier(+, expression)
+                                    listener: handleIdentifier(runtimeType, expression)
+                                  listener: handleNoTypeArguments(.)
+                                  parseArgumentsOpt(runtimeType)
+                                    listener: handleNoArguments(.)
+                                  listener: handleSend(runtimeType, .)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(^)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(^)
+                                listener: handleSend(hashCode, ^)
+                          listener: handleEndingBinaryExpression(.)
+                        listener: endBinaryExpression(+)
+                        listener: beginBinaryExpression(^)
+                        parsePrecedenceExpression(^, 11, true)
+                          parseUnaryExpression(^, true)
+                            parsePrimary(^, expression)
+                              parseLiteralNull(^)
+                                listener: handleLiteralNull(null)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(+)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(+)
+                                listener: handleSend(hashCode, +)
+                          listener: handleEndingBinaryExpression(.)
+                          listener: beginBinaryExpression(+)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                                  listener: handleLiteralInt(3)
+                          listener: endBinaryExpression(+)
+                        listener: endBinaryExpression(^)
+                    ensureSemicolon(3)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(get, int, =>, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, g, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, g)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(g, methodDeclaration)
+                parseQualifiedRestOpt(g, methodDeclarationContinuation)
+                listener: handleNoTypeVariables({)
+                parseGetterOrFormalParameters(g, g, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
+                parseInitializersOpt(g)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(g)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(g, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseLiteralInt(return)
+                                  listener: handleLiteralInt(1)
+                            listener: beginBinaryExpression(+)
+                            parsePrecedenceExpression(+, 14, true)
+                              parseUnaryExpression(+, true)
+                                parsePrimary(+, expression)
+                                  parseSendOrFunctionLiteral(+, expression)
+                                    parseSend(+, expression)
+                                      ensureIdentifier(+, expression)
+                                        listener: handleIdentifier(runtimeType, expression)
+                                      listener: handleNoTypeArguments(.)
+                                      parseArgumentsOpt(runtimeType)
+                                        listener: handleNoArguments(.)
+                                      listener: handleSend(runtimeType, .)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(xor)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(xor)
+                                    listener: handleSend(hashCode, xor)
+                              listener: handleEndingBinaryExpression(.)
+                              rewriter()
+                            listener: endBinaryExpression(+)
+                            rewriter()
+                            parsePrecedenceExpression(^, 11, true)
+                              parseUnaryExpression(^, true)
+                                parsePrimary(^, expression)
+                                  parseLiteralNull(^)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                    parseArgumentsOpt(hashCode)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                            reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
+                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                            rewriter()
+                            listener: beginBinaryExpression(^)
+                            parsePrecedenceExpression(^, 11, true)
+                              parseUnaryExpression(^, true)
+                                parsePrimary(^, expression)
+                                  parseLiteralNull(^)
+                                    listener: handleLiteralNull(null)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(+)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(+)
+                                    listener: handleSend(hashCode, +)
+                              listener: handleEndingBinaryExpression(.)
+                              listener: beginBinaryExpression(+)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                                      listener: handleLiteralInt(3)
+                              listener: endBinaryExpression(+)
+                            listener: endBinaryExpression(^)
+                        ensureSemicolon(3)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(get, int, {, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', get, h, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, h)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(h, methodDeclaration)
+                parseQualifiedRestOpt(h, methodDeclarationContinuation)
+                listener: handleNoTypeVariables({)
+                parseGetterOrFormalParameters(h, h, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
+                parseInitializersOpt(h)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(h)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(h, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseLiteralInt(return)
+                                  listener: handleLiteralInt(1)
+                            listener: beginBinaryExpression(+)
+                            parsePrecedenceExpression(+, 14, true)
+                              parseUnaryExpression(+, true)
+                                parsePrimary(+, expression)
+                                  parseSendOrFunctionLiteral(+, expression)
+                                    parseSend(+, expression)
+                                      ensureIdentifier(+, expression)
+                                        listener: handleIdentifier(runtimeType, expression)
+                                      listener: handleNoTypeArguments(.)
+                                      parseArgumentsOpt(runtimeType)
+                                        listener: handleNoArguments(.)
+                                      listener: handleSend(runtimeType, .)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(^)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(^)
+                                    listener: handleSend(hashCode, ^)
+                              listener: handleEndingBinaryExpression(.)
+                            listener: endBinaryExpression(+)
+                            listener: beginBinaryExpression(^)
+                            parsePrecedenceExpression(^, 11, true)
+                              parseUnaryExpression(^, true)
+                                parsePrimary(^, expression)
+                                  parseLiteralNull(^)
+                                    listener: handleLiteralNull(null)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(+)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(+)
+                                    listener: handleSend(hashCode, +)
+                              listener: handleEndingBinaryExpression(.)
+                              listener: beginBinaryExpression(+)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                                      listener: handleLiteralInt(3)
+                              listener: endBinaryExpression(+)
+                            listener: endBinaryExpression(^)
+                        ensureSemicolon(3)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(get, int, {, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, i, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, i)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(i)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(i, methodDeclaration)
+                parseQualifiedRestOpt(i, methodDeclarationContinuation)
+                parseMethodTypeVar(i)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(i, i, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(i, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseSendOrFunctionLiteral(=>, expression)
+                              parseSend(=>, expression)
+                                ensureIdentifier(=>, expression)
+                                  listener: handleIdentifier(x, expression)
+                                listener: handleNoTypeArguments(xor)
+                                parseArgumentsOpt(x)
+                                  listener: handleNoArguments(xor)
+                                listener: handleSend(x, xor)
+                        rewriter()
+                        parsePrecedenceExpression(^, 11, true)
+                          parseUnaryExpression(^, true)
+                            parsePrimary(^, expression)
+                              parseSendOrFunctionLiteral(^, expression)
+                                parseSend(^, expression)
+                                  ensureIdentifier(^, expression)
+                                  parseArgumentsOpt(y)
+                        reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
+                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                        rewriter()
+                        listener: beginBinaryExpression(^)
+                        parsePrecedenceExpression(^, 11, true)
+                          parseUnaryExpression(^, true)
+                            parsePrimary(^, expression)
+                              parseSendOrFunctionLiteral(^, expression)
+                                parseSend(^, expression)
+                                  ensureIdentifier(^, expression)
+                                    listener: handleIdentifier(y, expression)
+                                  listener: handleNoTypeArguments(;)
+                                  parseArgumentsOpt(y)
+                                    listener: handleNoArguments(;)
+                                  listener: handleSend(y, ;)
+                        listener: endBinaryExpression(^)
+                    ensureSemicolon(y)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(null, int, (, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, j, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, j)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(j)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(j, methodDeclaration)
+                parseQualifiedRestOpt(j, methodDeclarationContinuation)
+                parseMethodTypeVar(j)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(j, j, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(j, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseSendOrFunctionLiteral(=>, expression)
+                              parseSend(=>, expression)
+                                ensureIdentifier(=>, expression)
+                                  listener: handleIdentifier(x, expression)
+                                listener: handleNoTypeArguments(^)
+                                parseArgumentsOpt(x)
+                                  listener: handleNoArguments(^)
+                                listener: handleSend(x, ^)
+                        listener: beginBinaryExpression(^)
+                        parsePrecedenceExpression(^, 11, true)
+                          parseUnaryExpression(^, true)
+                            parsePrimary(^, expression)
+                              parseSendOrFunctionLiteral(^, expression)
+                                parseSend(^, expression)
+                                  ensureIdentifier(^, expression)
+                                    listener: handleIdentifier(y, expression)
+                                  listener: handleNoTypeArguments(;)
+                                  parseArgumentsOpt(y)
+                                    listener: handleNoArguments(;)
+                                  listener: handleSend(y, ;)
+                        listener: endBinaryExpression(^)
+                    ensureSemicolon(y)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(null, int, (, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, k, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, k)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(k)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(k, methodDeclaration)
+                parseQualifiedRestOpt(k, methodDeclarationContinuation)
+                parseMethodTypeVar(k)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(k, k, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(k, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(x, expression)
+                                    listener: handleNoTypeArguments(xor)
+                                    parseArgumentsOpt(x)
+                                      listener: handleNoArguments(xor)
+                                    listener: handleSend(x, xor)
+                            rewriter()
+                            parsePrecedenceExpression(^, 11, true)
+                              parseUnaryExpression(^, true)
+                                parsePrimary(^, expression)
+                                  parseSendOrFunctionLiteral(^, expression)
+                                    parseSend(^, expression)
+                                      ensureIdentifier(^, expression)
+                                      parseArgumentsOpt(y)
+                            reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
+                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                            rewriter()
+                            listener: beginBinaryExpression(^)
+                            parsePrecedenceExpression(^, 11, true)
+                              parseUnaryExpression(^, true)
+                                parsePrimary(^, expression)
+                                  parseSendOrFunctionLiteral(^, expression)
+                                    parseSend(^, expression)
+                                      ensureIdentifier(^, expression)
+                                        listener: handleIdentifier(y, expression)
+                                      listener: handleNoTypeArguments(;)
+                                      parseArgumentsOpt(y)
+                                        listener: handleNoArguments(;)
+                                      listener: handleSend(y, ;)
+                            listener: endBinaryExpression(^)
+                        ensureSemicolon(y)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, l, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, l)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(l)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(l, methodDeclaration)
+                parseQualifiedRestOpt(l, methodDeclarationContinuation)
+                parseMethodTypeVar(l)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(l, l, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(l, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(x, expression)
+                                    listener: handleNoTypeArguments(^)
+                                    parseArgumentsOpt(x)
+                                      listener: handleNoArguments(^)
+                                    listener: handleSend(x, ^)
+                            listener: beginBinaryExpression(^)
+                            parsePrecedenceExpression(^, 11, true)
+                              parseUnaryExpression(^, true)
+                                parsePrimary(^, expression)
+                                  parseSendOrFunctionLiteral(^, expression)
+                                    parseSend(^, expression)
+                                      ensureIdentifier(^, expression)
+                                        listener: handleIdentifier(y, expression)
+                                      listener: handleNoTypeArguments(;)
+                                      parseArgumentsOpt(y)
+                                        listener: handleNoArguments(;)
+                                      listener: handleSend(y, ;)
+                            listener: endBinaryExpression(^)
+                        ensureSemicolon(y)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, m, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, m)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(m)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(m, methodDeclaration)
+                parseQualifiedRestOpt(m, methodDeclarationContinuation)
+                parseMethodTypeVar(m)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(m, m, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(m, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, int)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(z)
+                        listener: beginMetadataStar(int)
+                        listener: endMetadataStar(0)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(z)
+                        listener: handleType(int, null)
+                        listener: beginVariablesDeclaration(z, null, null)
+                        parseVariablesDeclarationRest(int, true)
+                          parseOptionallyInitializedIdentifier(int)
+                            ensureIdentifier(int, localVariableDeclaration)
+                              listener: handleIdentifier(z, localVariableDeclaration)
+                            listener: beginInitializedIdentifier(z)
+                            parseVariableInitializerOpt(z)
+                              listener: beginVariableInitializer(=)
+                              parseExpression(=)
+                                parsePrecedenceExpression(=, 1, true)
+                                  parseUnaryExpression(=, true)
+                                    parsePrimary(=, expression)
+                                      parseSendOrFunctionLiteral(=, expression)
+                                        parseSend(=, expression)
+                                          ensureIdentifier(=, expression)
+                                            listener: handleIdentifier(x, expression)
+                                          listener: handleNoTypeArguments(xor)
+                                          parseArgumentsOpt(x)
+                                            listener: handleNoArguments(xor)
+                                          listener: handleSend(x, xor)
+                                  rewriter()
+                                  parsePrecedenceExpression(^, 11, true)
+                                    parseUnaryExpression(^, true)
+                                      parsePrimary(^, expression)
+                                        parseSendOrFunctionLiteral(^, expression)
+                                          parseSend(^, expression)
+                                            ensureIdentifier(^, expression)
+                                            parseArgumentsOpt(y)
+                                  reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
+                                    listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                                  rewriter()
+                                  listener: beginBinaryExpression(^)
+                                  parsePrecedenceExpression(^, 11, true)
+                                    parseUnaryExpression(^, true)
+                                      parsePrimary(^, expression)
+                                        parseSendOrFunctionLiteral(^, expression)
+                                          parseSend(^, expression)
+                                            ensureIdentifier(^, expression)
+                                              listener: handleIdentifier(y, expression)
+                                            listener: handleNoTypeArguments(;)
+                                            parseArgumentsOpt(y)
+                                              listener: handleNoArguments(;)
+                                            listener: handleSend(y, ;)
+                                  listener: endBinaryExpression(^)
+                              listener: endVariableInitializer(=)
+                            listener: endInitializedIdentifier(z)
+                          ensureSemicolon(y)
+                          listener: endVariablesDeclaration(1, ;)
+                  notEofOrValue(}, return)
+                  parseStatement(;)
+                    parseStatementX(;)
+                      parseReturnStatement(;)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(z, expression)
+                                    listener: handleNoTypeArguments(;)
+                                    parseArgumentsOpt(z)
+                                      listener: handleNoArguments(;)
+                                    listener: handleSend(z, ;)
+                        ensureSemicolon(z)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(2, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, n, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, n)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(n)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(n, methodDeclaration)
+                parseQualifiedRestOpt(n, methodDeclarationContinuation)
+                parseMethodTypeVar(n)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(n, n, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(n, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, int)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(z)
+                        listener: beginMetadataStar(int)
+                        listener: endMetadataStar(0)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(z)
+                        listener: handleType(int, null)
+                        listener: beginVariablesDeclaration(z, null, null)
+                        parseVariablesDeclarationRest(int, true)
+                          parseOptionallyInitializedIdentifier(int)
+                            ensureIdentifier(int, localVariableDeclaration)
+                              listener: handleIdentifier(z, localVariableDeclaration)
+                            listener: beginInitializedIdentifier(z)
+                            parseVariableInitializerOpt(z)
+                              listener: beginVariableInitializer(=)
+                              parseExpression(=)
+                                parsePrecedenceExpression(=, 1, true)
+                                  parseUnaryExpression(=, true)
+                                    parsePrimary(=, expression)
+                                      parseSendOrFunctionLiteral(=, expression)
+                                        parseSend(=, expression)
+                                          ensureIdentifier(=, expression)
+                                            listener: handleIdentifier(x, expression)
+                                          listener: handleNoTypeArguments(^)
+                                          parseArgumentsOpt(x)
+                                            listener: handleNoArguments(^)
+                                          listener: handleSend(x, ^)
+                                  listener: beginBinaryExpression(^)
+                                  parsePrecedenceExpression(^, 11, true)
+                                    parseUnaryExpression(^, true)
+                                      parsePrimary(^, expression)
+                                        parseSendOrFunctionLiteral(^, expression)
+                                          parseSend(^, expression)
+                                            ensureIdentifier(^, expression)
+                                              listener: handleIdentifier(y, expression)
+                                            listener: handleNoTypeArguments(;)
+                                            parseArgumentsOpt(y)
+                                              listener: handleNoArguments(;)
+                                            listener: handleSend(y, ;)
+                                  listener: endBinaryExpression(^)
+                              listener: endVariableInitializer(=)
+                            listener: endInitializedIdentifier(z)
+                          ensureSemicolon(y)
+                          listener: endVariablesDeclaration(1, ;)
+                  notEofOrValue(}, return)
+                  parseStatement(;)
+                    parseStatementX(;)
+                      parseReturnStatement(;)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(z, expression)
+                                    listener: handleNoTypeArguments(;)
+                                    parseArgumentsOpt(z)
+                                      listener: handleNoArguments(;)
+                                    listener: handleSend(z, ;)
+                        ensureSemicolon(z)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(2, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, o, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, o)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(o)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(o, methodDeclaration)
+                parseQualifiedRestOpt(o, methodDeclarationContinuation)
+                parseMethodTypeVar(o)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(o, o, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(o, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseLiteralInt(=>)
+                              listener: handleLiteralInt(1)
+                        listener: beginBinaryExpression(+)
+                        parsePrecedenceExpression(+, 14, true)
+                          parseUnaryExpression(+, true)
+                            parsePrimary(+, expression)
+                              parseSendOrFunctionLiteral(+, expression)
+                                parseSend(+, expression)
+                                  ensureIdentifier(+, expression)
+                                    listener: handleIdentifier(x, expression)
+                                  listener: handleNoTypeArguments(xor)
+                                  parseArgumentsOpt(x)
+                                    listener: handleNoArguments(xor)
+                                  listener: handleSend(x, xor)
+                          rewriter()
+                        listener: endBinaryExpression(+)
+                        rewriter()
+                        parsePrecedenceExpression(^, 11, true)
+                          parseUnaryExpression(^, true)
+                            parsePrimary(^, expression)
+                              parseSendOrFunctionLiteral(^, expression)
+                                parseSend(^, expression)
+                                  ensureIdentifier(^, expression)
+                                  parseArgumentsOpt(y)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                        reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
+                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                        rewriter()
+                        listener: beginBinaryExpression(^)
+                        parsePrecedenceExpression(^, 11, true)
+                          parseUnaryExpression(^, true)
+                            parsePrimary(^, expression)
+                              parseSendOrFunctionLiteral(^, expression)
+                                parseSend(^, expression)
+                                  ensureIdentifier(^, expression)
+                                    listener: handleIdentifier(y, expression)
+                                  listener: handleNoTypeArguments(+)
+                                  parseArgumentsOpt(y)
+                                    listener: handleNoArguments(+)
+                                  listener: handleSend(y, +)
+                          listener: beginBinaryExpression(+)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                                  listener: handleLiteralInt(3)
+                          listener: endBinaryExpression(+)
+                        listener: endBinaryExpression(^)
+                    ensureSemicolon(3)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(null, int, (, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, p, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, p)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(p)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(p, methodDeclaration)
+                parseQualifiedRestOpt(p, methodDeclarationContinuation)
+                parseMethodTypeVar(p)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(p, p, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(p, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseLiteralInt(=>)
+                              listener: handleLiteralInt(1)
+                        listener: beginBinaryExpression(+)
+                        parsePrecedenceExpression(+, 14, true)
+                          parseUnaryExpression(+, true)
+                            parsePrimary(+, expression)
+                              parseSendOrFunctionLiteral(+, expression)
+                                parseSend(+, expression)
+                                  ensureIdentifier(+, expression)
+                                    listener: handleIdentifier(x, expression)
+                                  listener: handleNoTypeArguments(^)
+                                  parseArgumentsOpt(x)
+                                    listener: handleNoArguments(^)
+                                  listener: handleSend(x, ^)
+                        listener: endBinaryExpression(+)
+                        listener: beginBinaryExpression(^)
+                        parsePrecedenceExpression(^, 11, true)
+                          parseUnaryExpression(^, true)
+                            parsePrimary(^, expression)
+                              parseSendOrFunctionLiteral(^, expression)
+                                parseSend(^, expression)
+                                  ensureIdentifier(^, expression)
+                                    listener: handleIdentifier(y, expression)
+                                  listener: handleNoTypeArguments(+)
+                                  parseArgumentsOpt(y)
+                                    listener: handleNoArguments(+)
+                                  listener: handleSend(y, +)
+                          listener: beginBinaryExpression(+)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                                  listener: handleLiteralInt(3)
+                          listener: endBinaryExpression(+)
+                        listener: endBinaryExpression(^)
+                    ensureSemicolon(3)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(null, int, (, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, q, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, q)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(q)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(q, methodDeclaration)
+                parseQualifiedRestOpt(q, methodDeclarationContinuation)
+                parseMethodTypeVar(q)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(q, q, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(q, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseLiteralInt(return)
+                                  listener: handleLiteralInt(1)
+                            listener: beginBinaryExpression(+)
+                            parsePrecedenceExpression(+, 14, true)
+                              parseUnaryExpression(+, true)
+                                parsePrimary(+, expression)
+                                  parseSendOrFunctionLiteral(+, expression)
+                                    parseSend(+, expression)
+                                      ensureIdentifier(+, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(xor)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(xor)
+                                      listener: handleSend(x, xor)
+                              rewriter()
+                            listener: endBinaryExpression(+)
+                            rewriter()
+                            parsePrecedenceExpression(^, 11, true)
+                              parseUnaryExpression(^, true)
+                                parsePrimary(^, expression)
+                                  parseSendOrFunctionLiteral(^, expression)
+                                    parseSend(^, expression)
+                                      ensureIdentifier(^, expression)
+                                      parseArgumentsOpt(y)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                            reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
+                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                            rewriter()
+                            listener: beginBinaryExpression(^)
+                            parsePrecedenceExpression(^, 11, true)
+                              parseUnaryExpression(^, true)
+                                parsePrimary(^, expression)
+                                  parseSendOrFunctionLiteral(^, expression)
+                                    parseSend(^, expression)
+                                      ensureIdentifier(^, expression)
+                                        listener: handleIdentifier(y, expression)
+                                      listener: handleNoTypeArguments(+)
+                                      parseArgumentsOpt(y)
+                                        listener: handleNoArguments(+)
+                                      listener: handleSend(y, +)
+                              listener: beginBinaryExpression(+)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                                      listener: handleLiteralInt(3)
+                              listener: endBinaryExpression(+)
+                            listener: endBinaryExpression(^)
+                        ensureSemicolon(3)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, r, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, r)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(r)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(r, methodDeclaration)
+                parseQualifiedRestOpt(r, methodDeclarationContinuation)
+                parseMethodTypeVar(r)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(r, r, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(r, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseLiteralInt(return)
+                                  listener: handleLiteralInt(1)
+                            listener: beginBinaryExpression(+)
+                            parsePrecedenceExpression(+, 14, true)
+                              parseUnaryExpression(+, true)
+                                parsePrimary(+, expression)
+                                  parseSendOrFunctionLiteral(+, expression)
+                                    parseSend(+, expression)
+                                      ensureIdentifier(+, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(^)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(^)
+                                      listener: handleSend(x, ^)
+                            listener: endBinaryExpression(+)
+                            listener: beginBinaryExpression(^)
+                            parsePrecedenceExpression(^, 11, true)
+                              parseUnaryExpression(^, true)
+                                parsePrimary(^, expression)
+                                  parseSendOrFunctionLiteral(^, expression)
+                                    parseSend(^, expression)
+                                      ensureIdentifier(^, expression)
+                                        listener: handleIdentifier(y, expression)
+                                      listener: handleNoTypeArguments(+)
+                                      parseArgumentsOpt(y)
+                                        listener: handleNoArguments(+)
+                                      listener: handleSend(y, +)
+                              listener: beginBinaryExpression(+)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                                      listener: handleLiteralInt(3)
+                              listener: endBinaryExpression(+)
+                            listener: endBinaryExpression(^)
+                        ensureSemicolon(3)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, s)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(s)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              isReservedKeyword(()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, s, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, s)
+                listener: handleNoType(})
+                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
+                  listener: handleIdentifier(s, methodDeclaration)
+                parseQualifiedRestOpt(s, methodDeclarationContinuation)
+                parseMethodTypeVar(s)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(s, s, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(s, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, s)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(s)
+                        parseExpressionStatement({)
+                          parseExpression({)
+                            parsePrecedenceExpression({, 1, true)
+                              parseUnaryExpression({, true)
+                                parsePrimary({, expression)
+                                  parseSendOrFunctionLiteral({, expression)
+                                    looksLikeFunctionBody(;)
+                                    parseSend({, expression)
+                                      ensureIdentifier({, expression)
+                                        listener: handleIdentifier(s, expression)
+                                      listener: handleNoTypeArguments(()
+                                      parseArgumentsOpt(s)
+                                        parseArguments(s)
+                                          parseArgumentsRest(()
+                                            listener: beginArguments(()
+                                            parseExpression(()
+                                              parsePrecedenceExpression((, 1, true)
+                                                parseUnaryExpression((, true)
+                                                  parsePrimary((, expression)
+                                                    parseSendOrFunctionLiteral((, expression)
+                                                      parseSend((, expression)
+                                                        ensureIdentifier((, expression)
+                                                          listener: handleIdentifier(x, expression)
+                                                        listener: handleNoTypeArguments(xor)
+                                                        parseArgumentsOpt(x)
+                                                          listener: handleNoArguments(xor)
+                                                        listener: handleSend(x, xor)
+                                                rewriter()
+                                                parsePrecedenceExpression(^, 11, true)
+                                                  parseUnaryExpression(^, true)
+                                                    parsePrimary(^, expression)
+                                                      parseSendOrFunctionLiteral(^, expression)
+                                                        parseSend(^, expression)
+                                                          ensureIdentifier(^, expression)
+                                                          parseArgumentsOpt(y)
+                                                reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
+                                                  listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                                                rewriter()
+                                                listener: beginBinaryExpression(^)
+                                                parsePrecedenceExpression(^, 11, true)
+                                                  parseUnaryExpression(^, true)
+                                                    parsePrimary(^, expression)
+                                                      parseSendOrFunctionLiteral(^, expression)
+                                                        parseSend(^, expression)
+                                                          ensureIdentifier(^, expression)
+                                                            listener: handleIdentifier(y, expression)
+                                                          listener: handleNoTypeArguments(,)
+                                                          parseArgumentsOpt(y)
+                                                            listener: handleNoArguments(,)
+                                                          listener: handleSend(y, ,)
+                                                listener: endBinaryExpression(^)
+                                            parseExpression(,)
+                                              parsePrecedenceExpression(,, 1, true)
+                                                parseUnaryExpression(,, true)
+                                                  parsePrimary(,, expression)
+                                                    parseSendOrFunctionLiteral(,, expression)
+                                                      parseSend(,, expression)
+                                                        ensureIdentifier(,, expression)
+                                                          listener: handleIdentifier(x, expression)
+                                                        listener: handleNoTypeArguments(xor)
+                                                        parseArgumentsOpt(x)
+                                                          listener: handleNoArguments(xor)
+                                                        listener: handleSend(x, xor)
+                                                rewriter()
+                                                parsePrecedenceExpression(^, 11, true)
+                                                  parseUnaryExpression(^, true)
+                                                    parsePrimary(^, expression)
+                                                      parseSendOrFunctionLiteral(^, expression)
+                                                        parseSend(^, expression)
+                                                          ensureIdentifier(^, expression)
+                                                          parseArgumentsOpt(y)
+                                                reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
+                                                  listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                                                rewriter()
+                                                listener: beginBinaryExpression(^)
+                                                parsePrecedenceExpression(^, 11, true)
+                                                  parseUnaryExpression(^, true)
+                                                    parsePrimary(^, expression)
+                                                      parseSendOrFunctionLiteral(^, expression)
+                                                        parseSend(^, expression)
+                                                          ensureIdentifier(^, expression)
+                                                            listener: handleIdentifier(y, expression)
+                                                          listener: handleNoTypeArguments())
+                                                          parseArgumentsOpt(y)
+                                                            listener: handleNoArguments())
+                                                          listener: handleSend(y, ))
+                                                listener: endBinaryExpression(^)
+                                            listener: endArguments(2, (, ))
+                                      listener: handleSend(s, ;)
+                          ensureSemicolon())
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, s)
+                  parseStatement(;)
+                    parseStatementX(;)
+                      parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                        looksLikeLocalFunction(s)
+                        parseExpressionStatement(;)
+                          parseExpression(;)
+                            parsePrecedenceExpression(;, 1, true)
+                              parseUnaryExpression(;, true)
+                                parsePrimary(;, expression)
+                                  parseSendOrFunctionLiteral(;, expression)
+                                    looksLikeFunctionBody(;)
+                                    parseSend(;, expression)
+                                      ensureIdentifier(;, expression)
+                                        listener: handleIdentifier(s, expression)
+                                      listener: handleNoTypeArguments(()
+                                      parseArgumentsOpt(s)
+                                        parseArguments(s)
+                                          parseArgumentsRest(()
+                                            listener: beginArguments(()
+                                            parseExpression(()
+                                              parsePrecedenceExpression((, 1, true)
+                                                parseUnaryExpression((, true)
+                                                  parsePrimary((, expression)
+                                                    parseSendOrFunctionLiteral((, expression)
+                                                      parseSend((, expression)
+                                                        ensureIdentifier((, expression)
+                                                          listener: handleIdentifier(x, expression)
+                                                        listener: handleNoTypeArguments(^)
+                                                        parseArgumentsOpt(x)
+                                                          listener: handleNoArguments(^)
+                                                        listener: handleSend(x, ^)
+                                                listener: beginBinaryExpression(^)
+                                                parsePrecedenceExpression(^, 11, true)
+                                                  parseUnaryExpression(^, true)
+                                                    parsePrimary(^, expression)
+                                                      parseSendOrFunctionLiteral(^, expression)
+                                                        parseSend(^, expression)
+                                                          ensureIdentifier(^, expression)
+                                                            listener: handleIdentifier(y, expression)
+                                                          listener: handleNoTypeArguments(,)
+                                                          parseArgumentsOpt(y)
+                                                            listener: handleNoArguments(,)
+                                                          listener: handleSend(y, ,)
+                                                listener: endBinaryExpression(^)
+                                            parseExpression(,)
+                                              parsePrecedenceExpression(,, 1, true)
+                                                parseUnaryExpression(,, true)
+                                                  parsePrimary(,, expression)
+                                                    parseSendOrFunctionLiteral(,, expression)
+                                                      parseSend(,, expression)
+                                                        ensureIdentifier(,, expression)
+                                                          listener: handleIdentifier(x, expression)
+                                                        listener: handleNoTypeArguments(^)
+                                                        parseArgumentsOpt(x)
+                                                          listener: handleNoArguments(^)
+                                                        listener: handleSend(x, ^)
+                                                listener: beginBinaryExpression(^)
+                                                parsePrecedenceExpression(^, 11, true)
+                                                  parseUnaryExpression(^, true)
+                                                    parsePrimary(^, expression)
+                                                      parseSendOrFunctionLiteral(^, expression)
+                                                        parseSend(^, expression)
+                                                          ensureIdentifier(^, expression)
+                                                            listener: handleIdentifier(y, expression)
+                                                          listener: handleNoTypeArguments())
+                                                          parseArgumentsOpt(y)
+                                                            listener: handleNoArguments())
+                                                          listener: handleSend(y, ))
+                                                listener: endBinaryExpression(^)
+                                            listener: endArguments(2, (, ))
+                                      listener: handleSend(s, ;)
+                          ensureSemicolon())
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(2, {, })
+                listener: endClassMethod(null, s, (, null, })
+              listener: endMember()
+            notEofOrValue(}, Key)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(Key)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              isReservedKeyword(()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, Key, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, Key)
+                listener: handleNoType(})
+                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
+                  listener: handleIdentifier(Key, methodDeclaration)
+                parseQualifiedRestOpt(Key, methodDeclarationContinuation)
+                parseMethodTypeVar(Key)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(Key, Key, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(Key, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  parseInitializers(:)
+                    listener: beginInitializers(:)
+                    parseInitializer(:)
+                      listener: beginInitializer(foo)
+                      parseInitializerExpressionRest(:)
+                        parseExpression(:)
+                          parsePrecedenceExpression(:, 1, true)
+                            parseUnaryExpression(:, true)
+                              parsePrimary(:, expression)
+                                parseSendOrFunctionLiteral(:, expression)
+                                  parseSend(:, expression)
+                                    ensureIdentifier(:, expression)
+                                      listener: handleIdentifier(foo, expression)
+                                    listener: handleNoTypeArguments(=)
+                                    parseArgumentsOpt(foo)
+                                      listener: handleNoArguments(=)
+                                    listener: handleSend(foo, =)
+                            parsePrecedenceExpression(=, 1, true)
+                              parseUnaryExpression(=, true)
+                                parsePrimary(=, expression)
+                                  parseSendOrFunctionLiteral(=, expression)
+                                    parseSend(=, expression)
+                                      ensureIdentifier(=, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(xor)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(xor)
+                                      listener: handleSend(x, xor)
+                              rewriter()
+                              parsePrecedenceExpression(^, 11, true)
+                                parseUnaryExpression(^, true)
+                                  parsePrimary(^, expression)
+                                    parseSendOrFunctionLiteral(^, expression)
+                                      parseSend(^, expression)
+                                        ensureIdentifier(^, expression)
+                                        parseArgumentsOpt(y)
+                              reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
+                                listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                              rewriter()
+                              listener: beginBinaryExpression(^)
+                              parsePrecedenceExpression(^, 11, true)
+                                parseUnaryExpression(^, true)
+                                  parsePrimary(^, expression)
+                                    parseSendOrFunctionLiteral(^, expression)
+                                      parseSend(^, expression)
+                                        ensureIdentifier(^, expression)
+                                          listener: handleIdentifier(y, expression)
+                                        listener: handleNoTypeArguments(,)
+                                        parseArgumentsOpt(y)
+                                          listener: handleNoArguments(,)
+                                        listener: handleSend(y, ,)
+                              listener: endBinaryExpression(^)
+                            listener: handleAssignmentExpression(=)
+                        listener: endInitializer(,)
+                    parseInitializer(,)
+                      listener: beginInitializer(bar)
+                      parseInitializerExpressionRest(,)
+                        parseExpression(,)
+                          parsePrecedenceExpression(,, 1, true)
+                            parseUnaryExpression(,, true)
+                              parsePrimary(,, expression)
+                                parseSendOrFunctionLiteral(,, expression)
+                                  parseSend(,, expression)
+                                    ensureIdentifier(,, expression)
+                                      listener: handleIdentifier(bar, expression)
+                                    listener: handleNoTypeArguments(=)
+                                    parseArgumentsOpt(bar)
+                                      listener: handleNoArguments(=)
+                                    listener: handleSend(bar, =)
+                            parsePrecedenceExpression(=, 1, true)
+                              parseUnaryExpression(=, true)
+                                parsePrimary(=, expression)
+                                  parseSendOrFunctionLiteral(=, expression)
+                                    parseSend(=, expression)
+                                      ensureIdentifier(=, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(xor)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(xor)
+                                      listener: handleSend(x, xor)
+                              rewriter()
+                              parsePrecedenceExpression(^, 11, true)
+                                parseUnaryExpression(^, true)
+                                  parsePrimary(^, expression)
+                                    parseSendOrFunctionLiteral(^, expression)
+                                      parseSend(^, expression)
+                                        ensureIdentifier(^, expression)
+                                        parseArgumentsOpt(y)
+                              reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
+                                listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                              rewriter()
+                              listener: beginBinaryExpression(^)
+                              parsePrecedenceExpression(^, 11, true)
+                                parseUnaryExpression(^, true)
+                                  parsePrimary(^, expression)
+                                    parseSendOrFunctionLiteral(^, expression)
+                                      parseSend(^, expression)
+                                        ensureIdentifier(^, expression)
+                                          listener: handleIdentifier(y, expression)
+                                        listener: handleNoTypeArguments({)
+                                        parseArgumentsOpt(y)
+                                          listener: handleNoArguments({)
+                                        listener: handleSend(y, {)
+                              listener: endBinaryExpression(^)
+                            listener: handleAssignmentExpression(=)
+                        listener: endInitializer({)
+                    listener: endInitializers(2, :, {)
+                parseAsyncModifierOpt(y)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(y, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, print)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(print)
+                        parseExpressionStatement({)
+                          parseExpression({)
+                            parsePrecedenceExpression({, 1, true)
+                              parseUnaryExpression({, true)
+                                parsePrimary({, expression)
+                                  parseSendOrFunctionLiteral({, expression)
+                                    looksLikeFunctionBody(;)
+                                    parseSend({, expression)
+                                      ensureIdentifier({, expression)
+                                        listener: handleIdentifier(print, expression)
+                                      listener: handleNoTypeArguments(()
+                                      parseArgumentsOpt(print)
+                                        parseArguments(print)
+                                          parseArgumentsRest(()
+                                            listener: beginArguments(()
+                                            parseExpression(()
+                                              parsePrecedenceExpression((, 1, true)
+                                                parseUnaryExpression((, true)
+                                                  parsePrimary((, expression)
+                                                    parseLiteralString(()
+                                                      parseSingleLiteralString(()
+                                                        listener: beginLiteralString("hello )
+                                                        parseExpression(${)
+                                                          parsePrecedenceExpression(${, 1, true)
+                                                            parseUnaryExpression(${, true)
+                                                              parsePrimary(${, expression)
+                                                                parseSendOrFunctionLiteral(${, expression)
+                                                                  parseSend(${, expression)
+                                                                    ensureIdentifier(${, expression)
+                                                                      listener: handleIdentifier(x, expression)
+                                                                    listener: handleNoTypeArguments(xor)
+                                                                    parseArgumentsOpt(x)
+                                                                      listener: handleNoArguments(xor)
+                                                                    listener: handleSend(x, xor)
+                                                            rewriter()
+                                                            parsePrecedenceExpression(^, 11, true)
+                                                              parseUnaryExpression(^, true)
+                                                                parsePrimary(^, expression)
+                                                                  parseSendOrFunctionLiteral(^, expression)
+                                                                    parseSend(^, expression)
+                                                                      ensureIdentifier(^, expression)
+                                                                      parseArgumentsOpt(y)
+                                                            reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
+                                                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
+                                                            rewriter()
+                                                            listener: beginBinaryExpression(^)
+                                                            parsePrecedenceExpression(^, 11, true)
+                                                              parseUnaryExpression(^, true)
+                                                                parsePrimary(^, expression)
+                                                                  parseSendOrFunctionLiteral(^, expression)
+                                                                    parseSend(^, expression)
+                                                                      ensureIdentifier(^, expression)
+                                                                        listener: handleIdentifier(y, expression)
+                                                                      listener: handleNoTypeArguments(})
+                                                                      parseArgumentsOpt(y)
+                                                                        listener: handleNoArguments(})
+                                                                      listener: handleSend(y, })
+                                                            listener: endBinaryExpression(^)
+                                                        listener: handleInterpolationExpression(${, })
+                                                        parseStringPart(})
+                                                          listener: handleStringPart(")
+                                                        listener: endLiteralString(1, ))
+                                            listener: endArguments(1, (, ))
+                                      listener: handleSend(print, ;)
+                          ensureSemicolon())
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassConstructor(null, Key, (, :, })
+              listener: endMember()
+            notEofOrValue(}, Key)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(Key)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              isReservedKeyword(()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, Key, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, Key)
+                listener: handleNoType(})
+                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
+                  listener: handleIdentifier(Key, methodDeclaration)
+                parseQualifiedRestOpt(Key, methodDeclarationContinuation)
+                parseMethodTypeVar(Key)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(Key, Key, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(Key, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  parseInitializers(:)
+                    listener: beginInitializers(:)
+                    parseInitializer(:)
+                      listener: beginInitializer(foo)
+                      parseInitializerExpressionRest(:)
+                        parseExpression(:)
+                          parsePrecedenceExpression(:, 1, true)
+                            parseUnaryExpression(:, true)
+                              parsePrimary(:, expression)
+                                parseSendOrFunctionLiteral(:, expression)
+                                  parseSend(:, expression)
+                                    ensureIdentifier(:, expression)
+                                      listener: handleIdentifier(foo, expression)
+                                    listener: handleNoTypeArguments(=)
+                                    parseArgumentsOpt(foo)
+                                      listener: handleNoArguments(=)
+                                    listener: handleSend(foo, =)
+                            parsePrecedenceExpression(=, 1, true)
+                              parseUnaryExpression(=, true)
+                                parsePrimary(=, expression)
+                                  parseSendOrFunctionLiteral(=, expression)
+                                    parseSend(=, expression)
+                                      ensureIdentifier(=, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(^)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(^)
+                                      listener: handleSend(x, ^)
+                              listener: beginBinaryExpression(^)
+                              parsePrecedenceExpression(^, 11, true)
+                                parseUnaryExpression(^, true)
+                                  parsePrimary(^, expression)
+                                    parseSendOrFunctionLiteral(^, expression)
+                                      parseSend(^, expression)
+                                        ensureIdentifier(^, expression)
+                                          listener: handleIdentifier(y, expression)
+                                        listener: handleNoTypeArguments(,)
+                                        parseArgumentsOpt(y)
+                                          listener: handleNoArguments(,)
+                                        listener: handleSend(y, ,)
+                              listener: endBinaryExpression(^)
+                            listener: handleAssignmentExpression(=)
+                        listener: endInitializer(,)
+                    parseInitializer(,)
+                      listener: beginInitializer(bar)
+                      parseInitializerExpressionRest(,)
+                        parseExpression(,)
+                          parsePrecedenceExpression(,, 1, true)
+                            parseUnaryExpression(,, true)
+                              parsePrimary(,, expression)
+                                parseSendOrFunctionLiteral(,, expression)
+                                  parseSend(,, expression)
+                                    ensureIdentifier(,, expression)
+                                      listener: handleIdentifier(bar, expression)
+                                    listener: handleNoTypeArguments(=)
+                                    parseArgumentsOpt(bar)
+                                      listener: handleNoArguments(=)
+                                    listener: handleSend(bar, =)
+                            parsePrecedenceExpression(=, 1, true)
+                              parseUnaryExpression(=, true)
+                                parsePrimary(=, expression)
+                                  parseSendOrFunctionLiteral(=, expression)
+                                    parseSend(=, expression)
+                                      ensureIdentifier(=, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(^)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(^)
+                                      listener: handleSend(x, ^)
+                              listener: beginBinaryExpression(^)
+                              parsePrecedenceExpression(^, 11, true)
+                                parseUnaryExpression(^, true)
+                                  parsePrimary(^, expression)
+                                    parseSendOrFunctionLiteral(^, expression)
+                                      parseSend(^, expression)
+                                        ensureIdentifier(^, expression)
+                                          listener: handleIdentifier(y, expression)
+                                        listener: handleNoTypeArguments({)
+                                        parseArgumentsOpt(y)
+                                          listener: handleNoArguments({)
+                                        listener: handleSend(y, {)
+                              listener: endBinaryExpression(^)
+                            listener: handleAssignmentExpression(=)
+                        listener: endInitializer({)
+                    listener: endInitializers(2, :, {)
+                parseAsyncModifierOpt(y)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(y, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, print)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(print)
+                        parseExpressionStatement({)
+                          parseExpression({)
+                            parsePrecedenceExpression({, 1, true)
+                              parseUnaryExpression({, true)
+                                parsePrimary({, expression)
+                                  parseSendOrFunctionLiteral({, expression)
+                                    looksLikeFunctionBody(;)
+                                    parseSend({, expression)
+                                      ensureIdentifier({, expression)
+                                        listener: handleIdentifier(print, expression)
+                                      listener: handleNoTypeArguments(()
+                                      parseArgumentsOpt(print)
+                                        parseArguments(print)
+                                          parseArgumentsRest(()
+                                            listener: beginArguments(()
+                                            parseExpression(()
+                                              parsePrecedenceExpression((, 1, true)
+                                                parseUnaryExpression((, true)
+                                                  parsePrimary((, expression)
+                                                    parseLiteralString(()
+                                                      parseSingleLiteralString(()
+                                                        listener: beginLiteralString("hello )
+                                                        parseExpression(${)
+                                                          parsePrecedenceExpression(${, 1, true)
+                                                            parseUnaryExpression(${, true)
+                                                              parsePrimary(${, expression)
+                                                                parseSendOrFunctionLiteral(${, expression)
+                                                                  parseSend(${, expression)
+                                                                    ensureIdentifier(${, expression)
+                                                                      listener: handleIdentifier(x, expression)
+                                                                    listener: handleNoTypeArguments(^)
+                                                                    parseArgumentsOpt(x)
+                                                                      listener: handleNoArguments(^)
+                                                                    listener: handleSend(x, ^)
+                                                            listener: beginBinaryExpression(^)
+                                                            parsePrecedenceExpression(^, 11, true)
+                                                              parseUnaryExpression(^, true)
+                                                                parsePrimary(^, expression)
+                                                                  parseSendOrFunctionLiteral(^, expression)
+                                                                    parseSend(^, expression)
+                                                                      ensureIdentifier(^, expression)
+                                                                        listener: handleIdentifier(y, expression)
+                                                                      listener: handleNoTypeArguments(})
+                                                                      parseArgumentsOpt(y)
+                                                                        listener: handleNoArguments(})
+                                                                      listener: handleSend(y, })
+                                                            listener: endBinaryExpression(^)
+                                                        listener: handleInterpolationExpression(${, })
+                                                        parseStringPart(})
+                                                          listener: handleStringPart(")
+                                                        listener: endLiteralString(1, ))
+                                            listener: endArguments(1, (, ))
+                                      listener: handleSend(print, ;)
+                          ensureSemicolon())
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassConstructor(null, Key, (, :, })
+              listener: endMember()
+            notEofOrValue(}, not_currently_working)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(not_currently_working)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              isReservedKeyword(()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, not_currently_working, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, not_currently_working)
+                listener: handleNoType(})
+                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
+                  listener: handleIdentifier(not_currently_working, methodDeclaration)
+                parseQualifiedRestOpt(not_currently_working, methodDeclarationContinuation)
+                parseMethodTypeVar(not_currently_working)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(not_currently_working, not_currently_working, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(not_currently_working, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, x)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(xor)
+                        listener: beginMetadataStar(x)
+                        listener: endMetadataStar(0)
+                        listener: handleIdentifier(x, typeReference)
+                        listener: handleNoTypeArguments(xor)
+                        listener: handleType(x, null)
+                        listener: beginVariablesDeclaration(xor, null, null)
+                        parseVariablesDeclarationRest(x, true)
+                          parseOptionallyInitializedIdentifier(x)
+                            ensureIdentifier(x, localVariableDeclaration)
+                              listener: handleIdentifier(xor, localVariableDeclaration)
+                            listener: beginInitializedIdentifier(xor)
+                            parseVariableInitializerOpt(xor)
+                              listener: handleNoVariableInitializer(xor)
+                            listener: endInitializedIdentifier(xor)
+                          ensureSemicolon(xor)
+                            reportRecoverableError(xor, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
+                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], xor, xor)
+                            rewriter()
+                          listener: endVariablesDeclaration(1, ;)
+                  notEofOrValue(}, y)
+                  parseStatement(;)
+                    parseStatementX(;)
+                      parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                        looksLikeLocalFunction(y)
+                        parseExpressionStatement(;)
+                          parseExpression(;)
+                            parsePrecedenceExpression(;, 1, true)
+                              parseUnaryExpression(;, true)
+                                parsePrimary(;, expression)
+                                  parseSendOrFunctionLiteral(;, expression)
+                                    parseSend(;, expression)
+                                      ensureIdentifier(;, expression)
+                                        listener: handleIdentifier(y, expression)
+                                      listener: handleNoTypeArguments(;)
+                                      parseArgumentsOpt(y)
+                                        listener: handleNoArguments(;)
+                                      listener: handleSend(y, ;)
+                          ensureSemicolon(y)
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, x)
+                  parseStatement(;)
+                    parseStatementX(;)
+                      parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                        looksLikeLocalFunction(x)
+                        parseExpressionStatement(;)
+                          parseExpression(;)
+                            parsePrecedenceExpression(;, 1, true)
+                              parseUnaryExpression(;, true)
+                                parsePrimary(;, expression)
+                                  parseSendOrFunctionLiteral(;, expression)
+                                    parseSend(;, expression)
+                                      ensureIdentifier(;, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(^)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(^)
+                                      listener: handleSend(x, ^)
+                              listener: beginBinaryExpression(^)
+                              parsePrecedenceExpression(^, 11, true)
+                                parseUnaryExpression(^, true)
+                                  parsePrimary(^, expression)
+                                    parseSendOrFunctionLiteral(^, expression)
+                                      parseSend(^, expression)
+                                        ensureIdentifier(^, expression)
+                                          listener: handleIdentifier(y, expression)
+                                        listener: handleNoTypeArguments(;)
+                                        parseArgumentsOpt(y)
+                                          listener: handleNoArguments(;)
+                                        listener: handleSend(y, ;)
+                              listener: endBinaryExpression(^)
+                          ensureSemicolon(y)
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(3, {, })
+                listener: endClassMethod(null, not_currently_working, (, null, })
+              listener: endMember()
+            notEofOrValue(}, })
+            listener: endClassOrMixinBody(DeclarationKind.Class, 22, {, })
+          listener: endClassDeclaration(abstract, })
+  listener: endTopLevelDeclaration()
+  reportAllErrorTokens(abstract)
+  listener: endCompilationUnit(1, )
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.parser.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.parser.expect
new file mode 100644
index 0000000..c51d463
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.parser.expect
@@ -0,0 +1,87 @@
+NOTICE: Stream was rewritten by parser!
+
+abstract class Key {
+int get a => runtimeType.hashCode ^ null.hashCode;
+int get b => runtimeType.hashCode ^ null.hashCode;
+int get c { return runtimeType.hashCode ^ null.hashCode; }
+int get d { return runtimeType.hashCode ^ null.hashCode; }
+
+int get e => 1 + runtimeType.hashCode ^ null.hashCode + 3;
+int get f => 1 + runtimeType.hashCode ^ null.hashCode + 3;
+int get g { return 1 + runtimeType.hashCode ^ null.hashCode + 3; }
+int get h { return 1 + runtimeType.hashCode ^ null.hashCode + 3; }
+
+int i(int x, int y) => x ^ y;
+int j(int x, int y) => x ^ y;
+int k(int x, int y) { return x ^ y; }
+int l(int x, int y) { return x ^ y; }
+int m(int x, int y) { int z = x ^ y; return z; }
+int n(int x, int y) { int z = x ^ y; return z; }
+
+int o(int x, int y) => 1 + x ^ y + 3;
+int p(int x, int y) => 1 + x ^ y + 3;
+int q(int x, int y) { return 1 + x ^ y + 3; }
+int r(int x, int y) { return 1 + x ^ y + 3; }
+
+s(int x, int y) {
+s(x ^ y, x ^ y);
+s(x ^ y, x ^ y);
+}
+
+Key(int x, int y) : foo = x ^ y, bar = x ^ y {
+print("hello ${x ^ y}");
+}
+
+Key(int x, int y) : foo = x ^ y, bar = x ^ y {
+print("hello ${x ^ y}");
+}
+
+not_currently_working(int x, int y) {
+x xor ;y;
+x ^ y;
+}
+}
+
+
+abstract[KeywordToken] class[KeywordToken] Key[StringToken] {[BeginToken]
+int[StringToken] get[KeywordToken] a[StringToken] =>[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] ^[ReplacementToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] b[StringToken] =>[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] ^[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] c[StringToken] {[BeginToken] return[KeywordToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] ^[ReplacementToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] get[KeywordToken] d[StringToken] {[BeginToken] return[KeywordToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] ^[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] get[KeywordToken] e[StringToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] ^[ReplacementToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] f[StringToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] ^[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] g[StringToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] ^[ReplacementToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] get[KeywordToken] h[StringToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] ^[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] i[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] x[StringToken] ^[ReplacementToken] y[StringToken];[SimpleToken]
+int[StringToken] j[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] x[StringToken] ^[SimpleToken] y[StringToken];[SimpleToken]
+int[StringToken] k[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] x[StringToken] ^[ReplacementToken] y[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] l[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] x[StringToken] ^[SimpleToken] y[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] m[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] int[StringToken] z[StringToken] =[SimpleToken] x[StringToken] ^[ReplacementToken] y[StringToken];[SimpleToken] return[KeywordToken] z[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] n[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] int[StringToken] z[StringToken] =[SimpleToken] x[StringToken] ^[SimpleToken] y[StringToken];[SimpleToken] return[KeywordToken] z[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] o[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] x[StringToken] ^[ReplacementToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] p[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] x[StringToken] ^[SimpleToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] q[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] x[StringToken] ^[ReplacementToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] r[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] x[StringToken] ^[SimpleToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+
+s[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken]
+s[StringToken]([BeginToken]x[StringToken] ^[ReplacementToken] y[StringToken],[SimpleToken] x[StringToken] ^[ReplacementToken] y[StringToken])[SimpleToken];[SimpleToken]
+s[StringToken]([BeginToken]x[StringToken] ^[SimpleToken] y[StringToken],[SimpleToken] x[StringToken] ^[SimpleToken] y[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+Key[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] :[SimpleToken] foo[StringToken] =[SimpleToken] x[StringToken] ^[ReplacementToken] y[StringToken],[SimpleToken] bar[StringToken] =[SimpleToken] x[StringToken] ^[ReplacementToken] y[StringToken] {[BeginToken]
+print[StringToken]([BeginToken]"hello [StringToken]${[BeginToken]x[StringToken] ^[ReplacementToken] y[StringToken]}[SimpleToken]"[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+Key[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] :[SimpleToken] foo[StringToken] =[SimpleToken] x[StringToken] ^[SimpleToken] y[StringToken],[SimpleToken] bar[StringToken] =[SimpleToken] x[StringToken] ^[SimpleToken] y[StringToken] {[BeginToken]
+print[StringToken]([BeginToken]"hello [StringToken]${[BeginToken]x[StringToken] ^[SimpleToken] y[StringToken]}[SimpleToken]"[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+not_currently_working[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken]
+x[StringToken] xor[StringToken] ;[SyntheticToken]y[StringToken];[SimpleToken]
+x[StringToken] ^[SimpleToken] y[StringToken];[SimpleToken]
+}[SimpleToken]
+}[SimpleToken]
+[SimpleToken]
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.scanner.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.scanner.expect
new file mode 100644
index 0000000..e6fe2c9
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.scanner.expect
@@ -0,0 +1,85 @@
+abstract class Key {
+int get a => runtimeType.hashCode xor null.hashCode;
+int get b => runtimeType.hashCode ^ null.hashCode;
+int get c { return runtimeType.hashCode xor null.hashCode; }
+int get d { return runtimeType.hashCode ^ null.hashCode; }
+
+int get e => 1 + runtimeType.hashCode xor null.hashCode + 3;
+int get f => 1 + runtimeType.hashCode ^ null.hashCode + 3;
+int get g { return 1 + runtimeType.hashCode xor null.hashCode + 3; }
+int get h { return 1 + runtimeType.hashCode ^ null.hashCode + 3; }
+
+int i(int x, int y) => x xor y;
+int j(int x, int y) => x ^ y;
+int k(int x, int y) { return x xor y; }
+int l(int x, int y) { return x ^ y; }
+int m(int x, int y) { int z = x xor y; return z; }
+int n(int x, int y) { int z = x ^ y; return z; }
+
+int o(int x, int y) => 1 + x xor y + 3;
+int p(int x, int y) => 1 + x ^ y + 3;
+int q(int x, int y) { return 1 + x xor y + 3; }
+int r(int x, int y) { return 1 + x ^ y + 3; }
+
+s(int x, int y) {
+s(x xor y, x xor y);
+s(x ^ y, x ^ y);
+}
+
+Key(int x, int y) : foo = x xor y, bar = x xor y {
+print("hello ${x xor y}");
+}
+
+Key(int x, int y) : foo = x ^ y, bar = x ^ y {
+print("hello ${x ^ y}");
+}
+
+not_currently_working(int x, int y) {
+x xor y;
+x ^ y;
+}
+}
+
+
+abstract[KeywordToken] class[KeywordToken] Key[StringToken] {[BeginToken]
+int[StringToken] get[KeywordToken] a[StringToken] =>[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] xor[StringToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] b[StringToken] =>[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] ^[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] c[StringToken] {[BeginToken] return[KeywordToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] xor[StringToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] get[KeywordToken] d[StringToken] {[BeginToken] return[KeywordToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] ^[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] get[KeywordToken] e[StringToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] xor[StringToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] f[StringToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] ^[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] g[StringToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] xor[StringToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] get[KeywordToken] h[StringToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] ^[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] i[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] x[StringToken] xor[StringToken] y[StringToken];[SimpleToken]
+int[StringToken] j[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] x[StringToken] ^[SimpleToken] y[StringToken];[SimpleToken]
+int[StringToken] k[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] x[StringToken] xor[StringToken] y[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] l[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] x[StringToken] ^[SimpleToken] y[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] m[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] int[StringToken] z[StringToken] =[SimpleToken] x[StringToken] xor[StringToken] y[StringToken];[SimpleToken] return[KeywordToken] z[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] n[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] int[StringToken] z[StringToken] =[SimpleToken] x[StringToken] ^[SimpleToken] y[StringToken];[SimpleToken] return[KeywordToken] z[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] o[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] x[StringToken] xor[StringToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] p[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] x[StringToken] ^[SimpleToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] q[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] x[StringToken] xor[StringToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] r[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] x[StringToken] ^[SimpleToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+
+s[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken]
+s[StringToken]([BeginToken]x[StringToken] xor[StringToken] y[StringToken],[SimpleToken] x[StringToken] xor[StringToken] y[StringToken])[SimpleToken];[SimpleToken]
+s[StringToken]([BeginToken]x[StringToken] ^[SimpleToken] y[StringToken],[SimpleToken] x[StringToken] ^[SimpleToken] y[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+Key[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] :[SimpleToken] foo[StringToken] =[SimpleToken] x[StringToken] xor[StringToken] y[StringToken],[SimpleToken] bar[StringToken] =[SimpleToken] x[StringToken] xor[StringToken] y[StringToken] {[BeginToken]
+print[StringToken]([BeginToken]"hello [StringToken]${[BeginToken]x[StringToken] xor[StringToken] y[StringToken]}[SimpleToken]"[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+Key[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] :[SimpleToken] foo[StringToken] =[SimpleToken] x[StringToken] ^[SimpleToken] y[StringToken],[SimpleToken] bar[StringToken] =[SimpleToken] x[StringToken] ^[SimpleToken] y[StringToken] {[BeginToken]
+print[StringToken]([BeginToken]"hello [StringToken]${[BeginToken]x[StringToken] ^[SimpleToken] y[StringToken]}[SimpleToken]"[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+not_currently_working[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken]
+x[StringToken] xor[StringToken] y[StringToken];[SimpleToken]
+x[StringToken] ^[SimpleToken] y[StringToken];[SimpleToken]
+}[SimpleToken]
+}[SimpleToken]
+[SimpleToken]
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart b/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart
new file mode 100644
index 0000000..cf6ecb7
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart
@@ -0,0 +1,41 @@
+abstract class Key {
+  int get a => runtimeType.hashCode and null.hashCode;
+  int get b => runtimeType.hashCode & null.hashCode;
+  int get c { return runtimeType.hashCode and null.hashCode; }
+  int get d { return runtimeType.hashCode & null.hashCode; }
+
+  int get e => 1 + runtimeType.hashCode and null.hashCode + 3;
+  int get f => 1 + runtimeType.hashCode & null.hashCode + 3;
+  int get g { return 1 + runtimeType.hashCode and null.hashCode + 3; }
+  int get h { return 1 + runtimeType.hashCode & null.hashCode + 3; }
+
+  int i(int x, int y) => x and y;
+  int j(int x, int y) => x & y;
+  int k(int x, int y) { return x and y; }
+  int l(int x, int y) { return x & y; }
+  int m(int x, int y) { int z =  x and y; return z; }
+  int n(int x, int y) { int z = x & y; return z; }
+
+  int o(int x, int y) => 1 + x and y + 3;
+  int p(int x, int y) => 1 + x & y + 3;
+  int q(int x, int y) { return 1 + x and y + 3; }
+  int r(int x, int y) { return 1 + x & y + 3; }
+
+  s(int x, int y) {
+    s(x and y, x and y);
+    s(x & y, x & y);
+  }
+
+  Key(int x, int y) : foo = x and y, bar = x and y {
+    print("hello ${x and y}");
+  }
+
+  Key(int x, int y) : foo = x & y, bar = x & y {
+    print("hello ${x & y}");
+  }
+
+  not_currently_working(int x, int y) {
+    x and y;
+    x & y;
+  }
+}
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.expect
new file mode 100644
index 0000000..e907a22
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.expect
@@ -0,0 +1,1221 @@
+Problems reported:
+
+parser/error_recovery/issue_26810_and:2:37: Binary operator 'and' is written as '&' instead of the written out word.
+  int get a => runtimeType.hashCode and null.hashCode;
+                                    ^^^
+
+parser/error_recovery/issue_26810_and:4:43: Binary operator 'and' is written as '&' instead of the written out word.
+  int get c { return runtimeType.hashCode and null.hashCode; }
+                                          ^^^
+
+parser/error_recovery/issue_26810_and:7:41: Binary operator 'and' is written as '&' instead of the written out word.
+  int get e => 1 + runtimeType.hashCode and null.hashCode + 3;
+                                        ^^^
+
+parser/error_recovery/issue_26810_and:9:47: Binary operator 'and' is written as '&' instead of the written out word.
+  int get g { return 1 + runtimeType.hashCode and null.hashCode + 3; }
+                                              ^^^
+
+parser/error_recovery/issue_26810_and:12:28: Binary operator 'and' is written as '&' instead of the written out word.
+  int i(int x, int y) => x and y;
+                           ^^^
+
+parser/error_recovery/issue_26810_and:14:34: Binary operator 'and' is written as '&' instead of the written out word.
+  int k(int x, int y) { return x and y; }
+                                 ^^^
+
+parser/error_recovery/issue_26810_and:16:36: Binary operator 'and' is written as '&' instead of the written out word.
+  int m(int x, int y) { int z =  x and y; return z; }
+                                   ^^^
+
+parser/error_recovery/issue_26810_and:19:32: Binary operator 'and' is written as '&' instead of the written out word.
+  int o(int x, int y) => 1 + x and y + 3;
+                               ^^^
+
+parser/error_recovery/issue_26810_and:21:38: Binary operator 'and' is written as '&' instead of the written out word.
+  int q(int x, int y) { return 1 + x and y + 3; }
+                                     ^^^
+
+parser/error_recovery/issue_26810_and:25:9: Binary operator 'and' is written as '&' instead of the written out word.
+    s(x and y, x and y);
+        ^^^
+
+parser/error_recovery/issue_26810_and:25:18: Binary operator 'and' is written as '&' instead of the written out word.
+    s(x and y, x and y);
+                 ^^^
+
+parser/error_recovery/issue_26810_and:29:31: Binary operator 'and' is written as '&' instead of the written out word.
+  Key(int x, int y) : foo = x and y, bar = x and y {
+                              ^^^
+
+parser/error_recovery/issue_26810_and:29:46: Binary operator 'and' is written as '&' instead of the written out word.
+  Key(int x, int y) : foo = x and y, bar = x and y {
+                                             ^^^
+
+parser/error_recovery/issue_26810_and:30:22: Binary operator 'and' is written as '&' instead of the written out word.
+    print("hello ${x and y}");
+                     ^^^
+
+parser/error_recovery/issue_26810_and:38:7: Expected ';' after this.
+    x and y;
+      ^^^
+
+beginCompilationUnit(abstract)
+  beginMetadataStar(abstract)
+  endMetadataStar(0)
+  beginClassOrNamedMixinApplicationPrelude(abstract)
+    handleIdentifier(Key, classOrMixinDeclaration)
+    handleNoTypeVariables({)
+    beginClassDeclaration(abstract, abstract, Key)
+      handleNoType(Key)
+      handleClassExtends(null, 1)
+      handleClassNoWithClause()
+      handleClassOrMixinImplements(null, 0)
+      handleClassHeader(abstract, class, null)
+      beginClassOrMixinBody(DeclarationKind.Class, {)
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, a)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(a, methodDeclaration)
+            handleNoTypeVariables(=>)
+            handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleIdentifier(runtimeType, expression)
+            handleNoTypeArguments(.)
+            handleNoArguments(.)
+            handleSend(runtimeType, .)
+            handleIdentifier(hashCode, expressionContinuation)
+            handleNoTypeArguments(and)
+            handleNoArguments(and)
+            handleSend(hashCode, and)
+            handleEndingBinaryExpression(.)
+            handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+            beginBinaryExpression(&)
+              handleLiteralNull(null)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(hashCode, ;)
+              handleEndingBinaryExpression(.)
+            endBinaryExpression(&)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(get, int, =>, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, b)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(b, methodDeclaration)
+            handleNoTypeVariables(=>)
+            handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleIdentifier(runtimeType, expression)
+            handleNoTypeArguments(.)
+            handleNoArguments(.)
+            handleSend(runtimeType, .)
+            handleIdentifier(hashCode, expressionContinuation)
+            handleNoTypeArguments(&)
+            handleNoArguments(&)
+            handleSend(hashCode, &)
+            handleEndingBinaryExpression(.)
+            beginBinaryExpression(&)
+              handleLiteralNull(null)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(hashCode, ;)
+              handleEndingBinaryExpression(.)
+            endBinaryExpression(&)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(get, int, =>, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, c)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(c, methodDeclaration)
+            handleNoTypeVariables({)
+            handleNoFormalParameters({, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleIdentifier(runtimeType, expression)
+                handleNoTypeArguments(.)
+                handleNoArguments(.)
+                handleSend(runtimeType, .)
+                handleIdentifier(hashCode, expressionContinuation)
+                handleNoTypeArguments(and)
+                handleNoArguments(and)
+                handleSend(hashCode, and)
+                handleEndingBinaryExpression(.)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                beginBinaryExpression(&)
+                  handleLiteralNull(null)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(;)
+                  handleNoArguments(;)
+                  handleSend(hashCode, ;)
+                  handleEndingBinaryExpression(.)
+                endBinaryExpression(&)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(get, int, {, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, d)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(d, methodDeclaration)
+            handleNoTypeVariables({)
+            handleNoFormalParameters({, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleIdentifier(runtimeType, expression)
+                handleNoTypeArguments(.)
+                handleNoArguments(.)
+                handleSend(runtimeType, .)
+                handleIdentifier(hashCode, expressionContinuation)
+                handleNoTypeArguments(&)
+                handleNoArguments(&)
+                handleSend(hashCode, &)
+                handleEndingBinaryExpression(.)
+                beginBinaryExpression(&)
+                  handleLiteralNull(null)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(;)
+                  handleNoArguments(;)
+                  handleSend(hashCode, ;)
+                  handleEndingBinaryExpression(.)
+                endBinaryExpression(&)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(get, int, {, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, e)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(e, methodDeclaration)
+            handleNoTypeVariables(=>)
+            handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleLiteralInt(1)
+            beginBinaryExpression(+)
+              handleIdentifier(runtimeType, expression)
+              handleNoTypeArguments(.)
+              handleNoArguments(.)
+              handleSend(runtimeType, .)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(and)
+              handleNoArguments(and)
+              handleSend(hashCode, and)
+              handleEndingBinaryExpression(.)
+            endBinaryExpression(+)
+            handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+            beginBinaryExpression(&)
+              handleLiteralNull(null)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(+)
+              handleNoArguments(+)
+              handleSend(hashCode, +)
+              handleEndingBinaryExpression(.)
+              beginBinaryExpression(+)
+                handleLiteralInt(3)
+              endBinaryExpression(+)
+            endBinaryExpression(&)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(get, int, =>, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, f)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(f, methodDeclaration)
+            handleNoTypeVariables(=>)
+            handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleLiteralInt(1)
+            beginBinaryExpression(+)
+              handleIdentifier(runtimeType, expression)
+              handleNoTypeArguments(.)
+              handleNoArguments(.)
+              handleSend(runtimeType, .)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(&)
+              handleNoArguments(&)
+              handleSend(hashCode, &)
+              handleEndingBinaryExpression(.)
+            endBinaryExpression(+)
+            beginBinaryExpression(&)
+              handleLiteralNull(null)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(+)
+              handleNoArguments(+)
+              handleSend(hashCode, +)
+              handleEndingBinaryExpression(.)
+              beginBinaryExpression(+)
+                handleLiteralInt(3)
+              endBinaryExpression(+)
+            endBinaryExpression(&)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(get, int, =>, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, g)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(g, methodDeclaration)
+            handleNoTypeVariables({)
+            handleNoFormalParameters({, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleLiteralInt(1)
+                beginBinaryExpression(+)
+                  handleIdentifier(runtimeType, expression)
+                  handleNoTypeArguments(.)
+                  handleNoArguments(.)
+                  handleSend(runtimeType, .)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(and)
+                  handleNoArguments(and)
+                  handleSend(hashCode, and)
+                  handleEndingBinaryExpression(.)
+                endBinaryExpression(+)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                beginBinaryExpression(&)
+                  handleLiteralNull(null)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(+)
+                  handleNoArguments(+)
+                  handleSend(hashCode, +)
+                  handleEndingBinaryExpression(.)
+                  beginBinaryExpression(+)
+                    handleLiteralInt(3)
+                  endBinaryExpression(+)
+                endBinaryExpression(&)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(get, int, {, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, h)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(h, methodDeclaration)
+            handleNoTypeVariables({)
+            handleNoFormalParameters({, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleLiteralInt(1)
+                beginBinaryExpression(+)
+                  handleIdentifier(runtimeType, expression)
+                  handleNoTypeArguments(.)
+                  handleNoArguments(.)
+                  handleSend(runtimeType, .)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(&)
+                  handleNoArguments(&)
+                  handleSend(hashCode, &)
+                  handleEndingBinaryExpression(.)
+                endBinaryExpression(+)
+                beginBinaryExpression(&)
+                  handleLiteralNull(null)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(+)
+                  handleNoArguments(+)
+                  handleSend(hashCode, +)
+                  handleEndingBinaryExpression(.)
+                  beginBinaryExpression(+)
+                    handleLiteralInt(3)
+                  endBinaryExpression(+)
+                endBinaryExpression(&)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(get, int, {, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, i)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(i)
+            handleType(int, null)
+            handleIdentifier(i, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleIdentifier(x, expression)
+            handleNoTypeArguments(and)
+            handleNoArguments(and)
+            handleSend(x, and)
+            handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+            beginBinaryExpression(&)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(y, ;)
+            endBinaryExpression(&)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(null, int, (, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, j)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(j)
+            handleType(int, null)
+            handleIdentifier(j, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleIdentifier(x, expression)
+            handleNoTypeArguments(&)
+            handleNoArguments(&)
+            handleSend(x, &)
+            beginBinaryExpression(&)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(y, ;)
+            endBinaryExpression(&)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(null, int, (, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, k)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(k)
+            handleType(int, null)
+            handleIdentifier(k, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(and)
+                handleNoArguments(and)
+                handleSend(x, and)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                beginBinaryExpression(&)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(;)
+                  handleNoArguments(;)
+                  handleSend(y, ;)
+                endBinaryExpression(&)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, l)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(l)
+            handleType(int, null)
+            handleIdentifier(l, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(&)
+                handleNoArguments(&)
+                handleSend(x, &)
+                beginBinaryExpression(&)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(;)
+                  handleNoArguments(;)
+                  handleSend(y, ;)
+                endBinaryExpression(&)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, m)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(m)
+            handleType(int, null)
+            handleIdentifier(m, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              handleIdentifier(int, typeReference)
+              handleNoTypeArguments(z)
+              handleType(int, null)
+              beginVariablesDeclaration(z, null, null)
+                handleIdentifier(z, localVariableDeclaration)
+                beginInitializedIdentifier(z)
+                  beginVariableInitializer(=)
+                    handleIdentifier(x, expression)
+                    handleNoTypeArguments(and)
+                    handleNoArguments(and)
+                    handleSend(x, and)
+                    handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                    beginBinaryExpression(&)
+                      handleIdentifier(y, expression)
+                      handleNoTypeArguments(;)
+                      handleNoArguments(;)
+                      handleSend(y, ;)
+                    endBinaryExpression(&)
+                  endVariableInitializer(=)
+                endInitializedIdentifier(z)
+              endVariablesDeclaration(1, ;)
+              beginReturnStatement(return)
+                handleIdentifier(z, expression)
+                handleNoTypeArguments(;)
+                handleNoArguments(;)
+                handleSend(z, ;)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(2, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, n)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(n)
+            handleType(int, null)
+            handleIdentifier(n, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              handleIdentifier(int, typeReference)
+              handleNoTypeArguments(z)
+              handleType(int, null)
+              beginVariablesDeclaration(z, null, null)
+                handleIdentifier(z, localVariableDeclaration)
+                beginInitializedIdentifier(z)
+                  beginVariableInitializer(=)
+                    handleIdentifier(x, expression)
+                    handleNoTypeArguments(&)
+                    handleNoArguments(&)
+                    handleSend(x, &)
+                    beginBinaryExpression(&)
+                      handleIdentifier(y, expression)
+                      handleNoTypeArguments(;)
+                      handleNoArguments(;)
+                      handleSend(y, ;)
+                    endBinaryExpression(&)
+                  endVariableInitializer(=)
+                endInitializedIdentifier(z)
+              endVariablesDeclaration(1, ;)
+              beginReturnStatement(return)
+                handleIdentifier(z, expression)
+                handleNoTypeArguments(;)
+                handleNoArguments(;)
+                handleSend(z, ;)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(2, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, o)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(o)
+            handleType(int, null)
+            handleIdentifier(o, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleLiteralInt(1)
+            beginBinaryExpression(+)
+              handleIdentifier(x, expression)
+              handleNoTypeArguments(and)
+              handleNoArguments(and)
+              handleSend(x, and)
+            endBinaryExpression(+)
+            handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+            beginBinaryExpression(&)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments(+)
+              handleNoArguments(+)
+              handleSend(y, +)
+              beginBinaryExpression(+)
+                handleLiteralInt(3)
+              endBinaryExpression(+)
+            endBinaryExpression(&)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(null, int, (, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, p)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(p)
+            handleType(int, null)
+            handleIdentifier(p, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleLiteralInt(1)
+            beginBinaryExpression(+)
+              handleIdentifier(x, expression)
+              handleNoTypeArguments(&)
+              handleNoArguments(&)
+              handleSend(x, &)
+            endBinaryExpression(+)
+            beginBinaryExpression(&)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments(+)
+              handleNoArguments(+)
+              handleSend(y, +)
+              beginBinaryExpression(+)
+                handleLiteralInt(3)
+              endBinaryExpression(+)
+            endBinaryExpression(&)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(null, int, (, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, q)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(q)
+            handleType(int, null)
+            handleIdentifier(q, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleLiteralInt(1)
+                beginBinaryExpression(+)
+                  handleIdentifier(x, expression)
+                  handleNoTypeArguments(and)
+                  handleNoArguments(and)
+                  handleSend(x, and)
+                endBinaryExpression(+)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                beginBinaryExpression(&)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(+)
+                  handleNoArguments(+)
+                  handleSend(y, +)
+                  beginBinaryExpression(+)
+                    handleLiteralInt(3)
+                  endBinaryExpression(+)
+                endBinaryExpression(&)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, r)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(r)
+            handleType(int, null)
+            handleIdentifier(r, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleLiteralInt(1)
+                beginBinaryExpression(+)
+                  handleIdentifier(x, expression)
+                  handleNoTypeArguments(&)
+                  handleNoArguments(&)
+                  handleSend(x, &)
+                endBinaryExpression(+)
+                beginBinaryExpression(&)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(+)
+                  handleNoArguments(+)
+                  handleSend(y, +)
+                  beginBinaryExpression(+)
+                    handleLiteralInt(3)
+                  endBinaryExpression(+)
+                endBinaryExpression(&)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(s)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, s)
+            handleNoType(})
+            handleIdentifier(s, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              handleIdentifier(s, expression)
+              handleNoTypeArguments(()
+              beginArguments(()
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(and)
+                handleNoArguments(and)
+                handleSend(x, and)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                beginBinaryExpression(&)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(,)
+                  handleNoArguments(,)
+                  handleSend(y, ,)
+                endBinaryExpression(&)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(and)
+                handleNoArguments(and)
+                handleSend(x, and)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                beginBinaryExpression(&)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments())
+                  handleNoArguments())
+                  handleSend(y, ))
+                endBinaryExpression(&)
+              endArguments(2, (, ))
+              handleSend(s, ;)
+              handleExpressionStatement(;)
+              handleIdentifier(s, expression)
+              handleNoTypeArguments(()
+              beginArguments(()
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(&)
+                handleNoArguments(&)
+                handleSend(x, &)
+                beginBinaryExpression(&)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(,)
+                  handleNoArguments(,)
+                  handleSend(y, ,)
+                endBinaryExpression(&)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(&)
+                handleNoArguments(&)
+                handleSend(x, &)
+                beginBinaryExpression(&)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments())
+                  handleNoArguments())
+                  handleSend(y, ))
+                endBinaryExpression(&)
+              endArguments(2, (, ))
+              handleSend(s, ;)
+              handleExpressionStatement(;)
+            endBlockFunctionBody(2, {, })
+          endClassMethod(null, s, (, null, })
+        endMember()
+        beginMetadataStar(Key)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, Key)
+            handleNoType(})
+            handleIdentifier(Key, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            beginInitializers(:)
+              beginInitializer(foo)
+                handleIdentifier(foo, expression)
+                handleNoTypeArguments(=)
+                handleNoArguments(=)
+                handleSend(foo, =)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(and)
+                handleNoArguments(and)
+                handleSend(x, and)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                beginBinaryExpression(&)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(,)
+                  handleNoArguments(,)
+                  handleSend(y, ,)
+                endBinaryExpression(&)
+                handleAssignmentExpression(=)
+              endInitializer(,)
+              beginInitializer(bar)
+                handleIdentifier(bar, expression)
+                handleNoTypeArguments(=)
+                handleNoArguments(=)
+                handleSend(bar, =)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(and)
+                handleNoArguments(and)
+                handleSend(x, and)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                beginBinaryExpression(&)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments({)
+                  handleNoArguments({)
+                  handleSend(y, {)
+                endBinaryExpression(&)
+                handleAssignmentExpression(=)
+              endInitializer({)
+            endInitializers(2, :, {)
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              handleIdentifier(print, expression)
+              handleNoTypeArguments(()
+              beginArguments(()
+                beginLiteralString("hello )
+                  handleIdentifier(x, expression)
+                  handleNoTypeArguments(and)
+                  handleNoArguments(and)
+                  handleSend(x, and)
+                  handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                  beginBinaryExpression(&)
+                    handleIdentifier(y, expression)
+                    handleNoTypeArguments(})
+                    handleNoArguments(})
+                    handleSend(y, })
+                  endBinaryExpression(&)
+                  handleInterpolationExpression(${, })
+                  handleStringPart(")
+                endLiteralString(1, ))
+              endArguments(1, (, ))
+              handleSend(print, ;)
+              handleExpressionStatement(;)
+            endBlockFunctionBody(1, {, })
+          endClassConstructor(null, Key, (, :, })
+        endMember()
+        beginMetadataStar(Key)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, Key)
+            handleNoType(})
+            handleIdentifier(Key, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            beginInitializers(:)
+              beginInitializer(foo)
+                handleIdentifier(foo, expression)
+                handleNoTypeArguments(=)
+                handleNoArguments(=)
+                handleSend(foo, =)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(&)
+                handleNoArguments(&)
+                handleSend(x, &)
+                beginBinaryExpression(&)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(,)
+                  handleNoArguments(,)
+                  handleSend(y, ,)
+                endBinaryExpression(&)
+                handleAssignmentExpression(=)
+              endInitializer(,)
+              beginInitializer(bar)
+                handleIdentifier(bar, expression)
+                handleNoTypeArguments(=)
+                handleNoArguments(=)
+                handleSend(bar, =)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(&)
+                handleNoArguments(&)
+                handleSend(x, &)
+                beginBinaryExpression(&)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments({)
+                  handleNoArguments({)
+                  handleSend(y, {)
+                endBinaryExpression(&)
+                handleAssignmentExpression(=)
+              endInitializer({)
+            endInitializers(2, :, {)
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              handleIdentifier(print, expression)
+              handleNoTypeArguments(()
+              beginArguments(()
+                beginLiteralString("hello )
+                  handleIdentifier(x, expression)
+                  handleNoTypeArguments(&)
+                  handleNoArguments(&)
+                  handleSend(x, &)
+                  beginBinaryExpression(&)
+                    handleIdentifier(y, expression)
+                    handleNoTypeArguments(})
+                    handleNoArguments(})
+                    handleSend(y, })
+                  endBinaryExpression(&)
+                  handleInterpolationExpression(${, })
+                  handleStringPart(")
+                endLiteralString(1, ))
+              endArguments(1, (, ))
+              handleSend(print, ;)
+              handleExpressionStatement(;)
+            endBlockFunctionBody(1, {, })
+          endClassConstructor(null, Key, (, :, })
+        endMember()
+        beginMetadataStar(not_currently_working)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, not_currently_working)
+            handleNoType(})
+            handleIdentifier(not_currently_working, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginMetadataStar(x)
+              endMetadataStar(0)
+              handleIdentifier(x, typeReference)
+              handleNoTypeArguments(and)
+              handleType(x, null)
+              beginVariablesDeclaration(and, null, null)
+                handleIdentifier(and, localVariableDeclaration)
+                beginInitializedIdentifier(and)
+                  handleNoVariableInitializer(and)
+                endInitializedIdentifier(and)
+                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], and, and)
+              endVariablesDeclaration(1, ;)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(y, ;)
+              handleExpressionStatement(;)
+              handleIdentifier(x, expression)
+              handleNoTypeArguments(&)
+              handleNoArguments(&)
+              handleSend(x, &)
+              beginBinaryExpression(&)
+                handleIdentifier(y, expression)
+                handleNoTypeArguments(;)
+                handleNoArguments(;)
+                handleSend(y, ;)
+              endBinaryExpression(&)
+              handleExpressionStatement(;)
+            endBlockFunctionBody(3, {, })
+          endClassMethod(null, not_currently_working, (, null, })
+        endMember()
+      endClassOrMixinBody(DeclarationKind.Class, 22, {, })
+    endClassDeclaration(abstract, })
+  endTopLevelDeclaration()
+endCompilationUnit(1, )
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.intertwined.expect
new file mode 100644
index 0000000..9abec744
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.intertwined.expect
@@ -0,0 +1,2594 @@
+parseUnit(abstract)
+  skipErrorTokens(abstract)
+  listener: beginCompilationUnit(abstract)
+  syntheticPreviousToken(abstract)
+  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
+    parseMetadataStar()
+      listener: beginMetadataStar(abstract)
+      listener: endMetadataStar(0)
+    parseTopLevelKeywordDeclaration(, class, Instance of 'DirectiveContext')
+      parseClassDeclarationModifiers(, class)
+        parseTopLevelKeywordModifiers(abstract, class)
+      parseClassOrNamedMixinApplication(abstract, class)
+        listener: beginClassOrNamedMixinApplicationPrelude(abstract)
+        ensureIdentifier(class, classOrMixinDeclaration)
+          listener: handleIdentifier(Key, classOrMixinDeclaration)
+        listener: handleNoTypeVariables({)
+        listener: beginClassDeclaration(abstract, abstract, Key)
+        parseClass(Key, abstract, class, Key)
+          parseClassHeaderOpt(Key, abstract, class)
+            parseClassExtendsOpt(Key)
+              listener: handleNoType(Key)
+              listener: handleClassExtends(null, 1)
+            parseWithClauseOpt(Key)
+              listener: handleClassNoWithClause()
+            parseClassOrMixinImplementsOpt(Key)
+              listener: handleClassOrMixinImplements(null, 0)
+            listener: handleClassHeader(abstract, class, null)
+          parseClassOrMixinOrExtensionBody(Key, DeclarationKind.Class, Key)
+            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Key)
+              parseMetadataStar({)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod({, null, null, null, null, null, null, {, Instance of 'SimpleType', get, a, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, a)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(a, methodDeclaration)
+                parseQualifiedRestOpt(a, methodDeclarationContinuation)
+                listener: handleNoTypeVariables(=>)
+                parseGetterOrFormalParameters(a, a, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+                parseInitializersOpt(a)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(a)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(a, false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseSendOrFunctionLiteral(=>, expression)
+                              parseSend(=>, expression)
+                                ensureIdentifier(=>, expression)
+                                  listener: handleIdentifier(runtimeType, expression)
+                                listener: handleNoTypeArguments(.)
+                                parseArgumentsOpt(runtimeType)
+                                  listener: handleNoArguments(.)
+                                listener: handleSend(runtimeType, .)
+                        parsePrimary(., expressionContinuation)
+                          parseSendOrFunctionLiteral(., expressionContinuation)
+                            parseSend(., expressionContinuation)
+                              ensureIdentifier(., expressionContinuation)
+                                listener: handleIdentifier(hashCode, expressionContinuation)
+                              listener: handleNoTypeArguments(and)
+                              parseArgumentsOpt(hashCode)
+                                listener: handleNoArguments(and)
+                              listener: handleSend(hashCode, and)
+                        listener: handleEndingBinaryExpression(.)
+                        rewriter()
+                        parsePrecedenceExpression(&, 12, true)
+                          parseUnaryExpression(&, true)
+                            parsePrimary(&, expression)
+                              parseLiteralNull(&)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                parseArgumentsOpt(hashCode)
+                        reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
+                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                        rewriter()
+                        listener: beginBinaryExpression(&)
+                        parsePrecedenceExpression(&, 12, true)
+                          parseUnaryExpression(&, true)
+                            parsePrimary(&, expression)
+                              parseLiteralNull(&)
+                                listener: handleLiteralNull(null)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(;)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(;)
+                                listener: handleSend(hashCode, ;)
+                          listener: handleEndingBinaryExpression(.)
+                        listener: endBinaryExpression(&)
+                    ensureSemicolon(hashCode)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(get, int, =>, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, b, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, b)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(b, methodDeclaration)
+                parseQualifiedRestOpt(b, methodDeclarationContinuation)
+                listener: handleNoTypeVariables(=>)
+                parseGetterOrFormalParameters(b, b, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+                parseInitializersOpt(b)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(b)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(b, false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseSendOrFunctionLiteral(=>, expression)
+                              parseSend(=>, expression)
+                                ensureIdentifier(=>, expression)
+                                  listener: handleIdentifier(runtimeType, expression)
+                                listener: handleNoTypeArguments(.)
+                                parseArgumentsOpt(runtimeType)
+                                  listener: handleNoArguments(.)
+                                listener: handleSend(runtimeType, .)
+                        parsePrimary(., expressionContinuation)
+                          parseSendOrFunctionLiteral(., expressionContinuation)
+                            parseSend(., expressionContinuation)
+                              ensureIdentifier(., expressionContinuation)
+                                listener: handleIdentifier(hashCode, expressionContinuation)
+                              listener: handleNoTypeArguments(&)
+                              parseArgumentsOpt(hashCode)
+                                listener: handleNoArguments(&)
+                              listener: handleSend(hashCode, &)
+                        listener: handleEndingBinaryExpression(.)
+                        listener: beginBinaryExpression(&)
+                        parsePrecedenceExpression(&, 12, true)
+                          parseUnaryExpression(&, true)
+                            parsePrimary(&, expression)
+                              parseLiteralNull(&)
+                                listener: handleLiteralNull(null)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(;)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(;)
+                                listener: handleSend(hashCode, ;)
+                          listener: handleEndingBinaryExpression(.)
+                        listener: endBinaryExpression(&)
+                    ensureSemicolon(hashCode)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(get, int, =>, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, c, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, c)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(c, methodDeclaration)
+                parseQualifiedRestOpt(c, methodDeclarationContinuation)
+                listener: handleNoTypeVariables({)
+                parseGetterOrFormalParameters(c, c, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
+                parseInitializersOpt(c)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(c)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(c, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(runtimeType, expression)
+                                    listener: handleNoTypeArguments(.)
+                                    parseArgumentsOpt(runtimeType)
+                                      listener: handleNoArguments(.)
+                                    listener: handleSend(runtimeType, .)
+                            parsePrimary(., expressionContinuation)
+                              parseSendOrFunctionLiteral(., expressionContinuation)
+                                parseSend(., expressionContinuation)
+                                  ensureIdentifier(., expressionContinuation)
+                                    listener: handleIdentifier(hashCode, expressionContinuation)
+                                  listener: handleNoTypeArguments(and)
+                                  parseArgumentsOpt(hashCode)
+                                    listener: handleNoArguments(and)
+                                  listener: handleSend(hashCode, and)
+                            listener: handleEndingBinaryExpression(.)
+                            rewriter()
+                            parsePrecedenceExpression(&, 12, true)
+                              parseUnaryExpression(&, true)
+                                parsePrimary(&, expression)
+                                  parseLiteralNull(&)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                    parseArgumentsOpt(hashCode)
+                            reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
+                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                            rewriter()
+                            listener: beginBinaryExpression(&)
+                            parsePrecedenceExpression(&, 12, true)
+                              parseUnaryExpression(&, true)
+                                parsePrimary(&, expression)
+                                  parseLiteralNull(&)
+                                    listener: handleLiteralNull(null)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(;)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(;)
+                                    listener: handleSend(hashCode, ;)
+                              listener: handleEndingBinaryExpression(.)
+                            listener: endBinaryExpression(&)
+                        ensureSemicolon(hashCode)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(get, int, {, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', get, d, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, d)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(d, methodDeclaration)
+                parseQualifiedRestOpt(d, methodDeclarationContinuation)
+                listener: handleNoTypeVariables({)
+                parseGetterOrFormalParameters(d, d, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
+                parseInitializersOpt(d)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(d)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(d, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(runtimeType, expression)
+                                    listener: handleNoTypeArguments(.)
+                                    parseArgumentsOpt(runtimeType)
+                                      listener: handleNoArguments(.)
+                                    listener: handleSend(runtimeType, .)
+                            parsePrimary(., expressionContinuation)
+                              parseSendOrFunctionLiteral(., expressionContinuation)
+                                parseSend(., expressionContinuation)
+                                  ensureIdentifier(., expressionContinuation)
+                                    listener: handleIdentifier(hashCode, expressionContinuation)
+                                  listener: handleNoTypeArguments(&)
+                                  parseArgumentsOpt(hashCode)
+                                    listener: handleNoArguments(&)
+                                  listener: handleSend(hashCode, &)
+                            listener: handleEndingBinaryExpression(.)
+                            listener: beginBinaryExpression(&)
+                            parsePrecedenceExpression(&, 12, true)
+                              parseUnaryExpression(&, true)
+                                parsePrimary(&, expression)
+                                  parseLiteralNull(&)
+                                    listener: handleLiteralNull(null)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(;)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(;)
+                                    listener: handleSend(hashCode, ;)
+                              listener: handleEndingBinaryExpression(.)
+                            listener: endBinaryExpression(&)
+                        ensureSemicolon(hashCode)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(get, int, {, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', get, e, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, e)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(e, methodDeclaration)
+                parseQualifiedRestOpt(e, methodDeclarationContinuation)
+                listener: handleNoTypeVariables(=>)
+                parseGetterOrFormalParameters(e, e, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+                parseInitializersOpt(e)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(e)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(e, false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseLiteralInt(=>)
+                              listener: handleLiteralInt(1)
+                        listener: beginBinaryExpression(+)
+                        parsePrecedenceExpression(+, 14, true)
+                          parseUnaryExpression(+, true)
+                            parsePrimary(+, expression)
+                              parseSendOrFunctionLiteral(+, expression)
+                                parseSend(+, expression)
+                                  ensureIdentifier(+, expression)
+                                    listener: handleIdentifier(runtimeType, expression)
+                                  listener: handleNoTypeArguments(.)
+                                  parseArgumentsOpt(runtimeType)
+                                    listener: handleNoArguments(.)
+                                  listener: handleSend(runtimeType, .)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(and)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(and)
+                                listener: handleSend(hashCode, and)
+                          listener: handleEndingBinaryExpression(.)
+                          rewriter()
+                        listener: endBinaryExpression(+)
+                        rewriter()
+                        parsePrecedenceExpression(&, 12, true)
+                          parseUnaryExpression(&, true)
+                            parsePrimary(&, expression)
+                              parseLiteralNull(&)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                parseArgumentsOpt(hashCode)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                        reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
+                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                        rewriter()
+                        listener: beginBinaryExpression(&)
+                        parsePrecedenceExpression(&, 12, true)
+                          parseUnaryExpression(&, true)
+                            parsePrimary(&, expression)
+                              parseLiteralNull(&)
+                                listener: handleLiteralNull(null)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(+)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(+)
+                                listener: handleSend(hashCode, +)
+                          listener: handleEndingBinaryExpression(.)
+                          listener: beginBinaryExpression(+)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                                  listener: handleLiteralInt(3)
+                          listener: endBinaryExpression(+)
+                        listener: endBinaryExpression(&)
+                    ensureSemicolon(3)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(get, int, =>, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, f, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, f)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(f, methodDeclaration)
+                parseQualifiedRestOpt(f, methodDeclarationContinuation)
+                listener: handleNoTypeVariables(=>)
+                parseGetterOrFormalParameters(f, f, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+                parseInitializersOpt(f)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(f)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(f, false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseLiteralInt(=>)
+                              listener: handleLiteralInt(1)
+                        listener: beginBinaryExpression(+)
+                        parsePrecedenceExpression(+, 14, true)
+                          parseUnaryExpression(+, true)
+                            parsePrimary(+, expression)
+                              parseSendOrFunctionLiteral(+, expression)
+                                parseSend(+, expression)
+                                  ensureIdentifier(+, expression)
+                                    listener: handleIdentifier(runtimeType, expression)
+                                  listener: handleNoTypeArguments(.)
+                                  parseArgumentsOpt(runtimeType)
+                                    listener: handleNoArguments(.)
+                                  listener: handleSend(runtimeType, .)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(&)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(&)
+                                listener: handleSend(hashCode, &)
+                          listener: handleEndingBinaryExpression(.)
+                        listener: endBinaryExpression(+)
+                        listener: beginBinaryExpression(&)
+                        parsePrecedenceExpression(&, 12, true)
+                          parseUnaryExpression(&, true)
+                            parsePrimary(&, expression)
+                              parseLiteralNull(&)
+                                listener: handleLiteralNull(null)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(+)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(+)
+                                listener: handleSend(hashCode, +)
+                          listener: handleEndingBinaryExpression(.)
+                          listener: beginBinaryExpression(+)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                                  listener: handleLiteralInt(3)
+                          listener: endBinaryExpression(+)
+                        listener: endBinaryExpression(&)
+                    ensureSemicolon(3)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(get, int, =>, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, g, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, g)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(g, methodDeclaration)
+                parseQualifiedRestOpt(g, methodDeclarationContinuation)
+                listener: handleNoTypeVariables({)
+                parseGetterOrFormalParameters(g, g, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
+                parseInitializersOpt(g)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(g)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(g, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseLiteralInt(return)
+                                  listener: handleLiteralInt(1)
+                            listener: beginBinaryExpression(+)
+                            parsePrecedenceExpression(+, 14, true)
+                              parseUnaryExpression(+, true)
+                                parsePrimary(+, expression)
+                                  parseSendOrFunctionLiteral(+, expression)
+                                    parseSend(+, expression)
+                                      ensureIdentifier(+, expression)
+                                        listener: handleIdentifier(runtimeType, expression)
+                                      listener: handleNoTypeArguments(.)
+                                      parseArgumentsOpt(runtimeType)
+                                        listener: handleNoArguments(.)
+                                      listener: handleSend(runtimeType, .)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(and)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(and)
+                                    listener: handleSend(hashCode, and)
+                              listener: handleEndingBinaryExpression(.)
+                              rewriter()
+                            listener: endBinaryExpression(+)
+                            rewriter()
+                            parsePrecedenceExpression(&, 12, true)
+                              parseUnaryExpression(&, true)
+                                parsePrimary(&, expression)
+                                  parseLiteralNull(&)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                    parseArgumentsOpt(hashCode)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                            reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
+                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                            rewriter()
+                            listener: beginBinaryExpression(&)
+                            parsePrecedenceExpression(&, 12, true)
+                              parseUnaryExpression(&, true)
+                                parsePrimary(&, expression)
+                                  parseLiteralNull(&)
+                                    listener: handleLiteralNull(null)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(+)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(+)
+                                    listener: handleSend(hashCode, +)
+                              listener: handleEndingBinaryExpression(.)
+                              listener: beginBinaryExpression(+)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                                      listener: handleLiteralInt(3)
+                              listener: endBinaryExpression(+)
+                            listener: endBinaryExpression(&)
+                        ensureSemicolon(3)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(get, int, {, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', get, h, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, h)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(h, methodDeclaration)
+                parseQualifiedRestOpt(h, methodDeclarationContinuation)
+                listener: handleNoTypeVariables({)
+                parseGetterOrFormalParameters(h, h, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
+                parseInitializersOpt(h)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(h)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(h, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseLiteralInt(return)
+                                  listener: handleLiteralInt(1)
+                            listener: beginBinaryExpression(+)
+                            parsePrecedenceExpression(+, 14, true)
+                              parseUnaryExpression(+, true)
+                                parsePrimary(+, expression)
+                                  parseSendOrFunctionLiteral(+, expression)
+                                    parseSend(+, expression)
+                                      ensureIdentifier(+, expression)
+                                        listener: handleIdentifier(runtimeType, expression)
+                                      listener: handleNoTypeArguments(.)
+                                      parseArgumentsOpt(runtimeType)
+                                        listener: handleNoArguments(.)
+                                      listener: handleSend(runtimeType, .)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(&)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(&)
+                                    listener: handleSend(hashCode, &)
+                              listener: handleEndingBinaryExpression(.)
+                            listener: endBinaryExpression(+)
+                            listener: beginBinaryExpression(&)
+                            parsePrecedenceExpression(&, 12, true)
+                              parseUnaryExpression(&, true)
+                                parsePrimary(&, expression)
+                                  parseLiteralNull(&)
+                                    listener: handleLiteralNull(null)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(+)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(+)
+                                    listener: handleSend(hashCode, +)
+                              listener: handleEndingBinaryExpression(.)
+                              listener: beginBinaryExpression(+)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                                      listener: handleLiteralInt(3)
+                              listener: endBinaryExpression(+)
+                            listener: endBinaryExpression(&)
+                        ensureSemicolon(3)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(get, int, {, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, i, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, i)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(i)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(i, methodDeclaration)
+                parseQualifiedRestOpt(i, methodDeclarationContinuation)
+                parseMethodTypeVar(i)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(i, i, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(i, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseSendOrFunctionLiteral(=>, expression)
+                              parseSend(=>, expression)
+                                ensureIdentifier(=>, expression)
+                                  listener: handleIdentifier(x, expression)
+                                listener: handleNoTypeArguments(and)
+                                parseArgumentsOpt(x)
+                                  listener: handleNoArguments(and)
+                                listener: handleSend(x, and)
+                        rewriter()
+                        parsePrecedenceExpression(&, 12, true)
+                          parseUnaryExpression(&, true)
+                            parsePrimary(&, expression)
+                              parseSendOrFunctionLiteral(&, expression)
+                                parseSend(&, expression)
+                                  ensureIdentifier(&, expression)
+                                  parseArgumentsOpt(y)
+                        reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
+                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                        rewriter()
+                        listener: beginBinaryExpression(&)
+                        parsePrecedenceExpression(&, 12, true)
+                          parseUnaryExpression(&, true)
+                            parsePrimary(&, expression)
+                              parseSendOrFunctionLiteral(&, expression)
+                                parseSend(&, expression)
+                                  ensureIdentifier(&, expression)
+                                    listener: handleIdentifier(y, expression)
+                                  listener: handleNoTypeArguments(;)
+                                  parseArgumentsOpt(y)
+                                    listener: handleNoArguments(;)
+                                  listener: handleSend(y, ;)
+                        listener: endBinaryExpression(&)
+                    ensureSemicolon(y)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(null, int, (, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, j, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, j)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(j)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(j, methodDeclaration)
+                parseQualifiedRestOpt(j, methodDeclarationContinuation)
+                parseMethodTypeVar(j)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(j, j, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(j, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseSendOrFunctionLiteral(=>, expression)
+                              parseSend(=>, expression)
+                                ensureIdentifier(=>, expression)
+                                  listener: handleIdentifier(x, expression)
+                                listener: handleNoTypeArguments(&)
+                                parseArgumentsOpt(x)
+                                  listener: handleNoArguments(&)
+                                listener: handleSend(x, &)
+                        listener: beginBinaryExpression(&)
+                        parsePrecedenceExpression(&, 12, true)
+                          parseUnaryExpression(&, true)
+                            parsePrimary(&, expression)
+                              parseSendOrFunctionLiteral(&, expression)
+                                parseSend(&, expression)
+                                  ensureIdentifier(&, expression)
+                                    listener: handleIdentifier(y, expression)
+                                  listener: handleNoTypeArguments(;)
+                                  parseArgumentsOpt(y)
+                                    listener: handleNoArguments(;)
+                                  listener: handleSend(y, ;)
+                        listener: endBinaryExpression(&)
+                    ensureSemicolon(y)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(null, int, (, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, k, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, k)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(k)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(k, methodDeclaration)
+                parseQualifiedRestOpt(k, methodDeclarationContinuation)
+                parseMethodTypeVar(k)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(k, k, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(k, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(x, expression)
+                                    listener: handleNoTypeArguments(and)
+                                    parseArgumentsOpt(x)
+                                      listener: handleNoArguments(and)
+                                    listener: handleSend(x, and)
+                            rewriter()
+                            parsePrecedenceExpression(&, 12, true)
+                              parseUnaryExpression(&, true)
+                                parsePrimary(&, expression)
+                                  parseSendOrFunctionLiteral(&, expression)
+                                    parseSend(&, expression)
+                                      ensureIdentifier(&, expression)
+                                      parseArgumentsOpt(y)
+                            reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
+                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                            rewriter()
+                            listener: beginBinaryExpression(&)
+                            parsePrecedenceExpression(&, 12, true)
+                              parseUnaryExpression(&, true)
+                                parsePrimary(&, expression)
+                                  parseSendOrFunctionLiteral(&, expression)
+                                    parseSend(&, expression)
+                                      ensureIdentifier(&, expression)
+                                        listener: handleIdentifier(y, expression)
+                                      listener: handleNoTypeArguments(;)
+                                      parseArgumentsOpt(y)
+                                        listener: handleNoArguments(;)
+                                      listener: handleSend(y, ;)
+                            listener: endBinaryExpression(&)
+                        ensureSemicolon(y)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, l, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, l)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(l)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(l, methodDeclaration)
+                parseQualifiedRestOpt(l, methodDeclarationContinuation)
+                parseMethodTypeVar(l)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(l, l, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(l, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(x, expression)
+                                    listener: handleNoTypeArguments(&)
+                                    parseArgumentsOpt(x)
+                                      listener: handleNoArguments(&)
+                                    listener: handleSend(x, &)
+                            listener: beginBinaryExpression(&)
+                            parsePrecedenceExpression(&, 12, true)
+                              parseUnaryExpression(&, true)
+                                parsePrimary(&, expression)
+                                  parseSendOrFunctionLiteral(&, expression)
+                                    parseSend(&, expression)
+                                      ensureIdentifier(&, expression)
+                                        listener: handleIdentifier(y, expression)
+                                      listener: handleNoTypeArguments(;)
+                                      parseArgumentsOpt(y)
+                                        listener: handleNoArguments(;)
+                                      listener: handleSend(y, ;)
+                            listener: endBinaryExpression(&)
+                        ensureSemicolon(y)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, m, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, m)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(m)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(m, methodDeclaration)
+                parseQualifiedRestOpt(m, methodDeclarationContinuation)
+                parseMethodTypeVar(m)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(m, m, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(m, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, int)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(z)
+                        listener: beginMetadataStar(int)
+                        listener: endMetadataStar(0)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(z)
+                        listener: handleType(int, null)
+                        listener: beginVariablesDeclaration(z, null, null)
+                        parseVariablesDeclarationRest(int, true)
+                          parseOptionallyInitializedIdentifier(int)
+                            ensureIdentifier(int, localVariableDeclaration)
+                              listener: handleIdentifier(z, localVariableDeclaration)
+                            listener: beginInitializedIdentifier(z)
+                            parseVariableInitializerOpt(z)
+                              listener: beginVariableInitializer(=)
+                              parseExpression(=)
+                                parsePrecedenceExpression(=, 1, true)
+                                  parseUnaryExpression(=, true)
+                                    parsePrimary(=, expression)
+                                      parseSendOrFunctionLiteral(=, expression)
+                                        parseSend(=, expression)
+                                          ensureIdentifier(=, expression)
+                                            listener: handleIdentifier(x, expression)
+                                          listener: handleNoTypeArguments(and)
+                                          parseArgumentsOpt(x)
+                                            listener: handleNoArguments(and)
+                                          listener: handleSend(x, and)
+                                  rewriter()
+                                  parsePrecedenceExpression(&, 12, true)
+                                    parseUnaryExpression(&, true)
+                                      parsePrimary(&, expression)
+                                        parseSendOrFunctionLiteral(&, expression)
+                                          parseSend(&, expression)
+                                            ensureIdentifier(&, expression)
+                                            parseArgumentsOpt(y)
+                                  reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
+                                    listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                                  rewriter()
+                                  listener: beginBinaryExpression(&)
+                                  parsePrecedenceExpression(&, 12, true)
+                                    parseUnaryExpression(&, true)
+                                      parsePrimary(&, expression)
+                                        parseSendOrFunctionLiteral(&, expression)
+                                          parseSend(&, expression)
+                                            ensureIdentifier(&, expression)
+                                              listener: handleIdentifier(y, expression)
+                                            listener: handleNoTypeArguments(;)
+                                            parseArgumentsOpt(y)
+                                              listener: handleNoArguments(;)
+                                            listener: handleSend(y, ;)
+                                  listener: endBinaryExpression(&)
+                              listener: endVariableInitializer(=)
+                            listener: endInitializedIdentifier(z)
+                          ensureSemicolon(y)
+                          listener: endVariablesDeclaration(1, ;)
+                  notEofOrValue(}, return)
+                  parseStatement(;)
+                    parseStatementX(;)
+                      parseReturnStatement(;)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(z, expression)
+                                    listener: handleNoTypeArguments(;)
+                                    parseArgumentsOpt(z)
+                                      listener: handleNoArguments(;)
+                                    listener: handleSend(z, ;)
+                        ensureSemicolon(z)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(2, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, n, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, n)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(n)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(n, methodDeclaration)
+                parseQualifiedRestOpt(n, methodDeclarationContinuation)
+                parseMethodTypeVar(n)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(n, n, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(n, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, int)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(z)
+                        listener: beginMetadataStar(int)
+                        listener: endMetadataStar(0)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(z)
+                        listener: handleType(int, null)
+                        listener: beginVariablesDeclaration(z, null, null)
+                        parseVariablesDeclarationRest(int, true)
+                          parseOptionallyInitializedIdentifier(int)
+                            ensureIdentifier(int, localVariableDeclaration)
+                              listener: handleIdentifier(z, localVariableDeclaration)
+                            listener: beginInitializedIdentifier(z)
+                            parseVariableInitializerOpt(z)
+                              listener: beginVariableInitializer(=)
+                              parseExpression(=)
+                                parsePrecedenceExpression(=, 1, true)
+                                  parseUnaryExpression(=, true)
+                                    parsePrimary(=, expression)
+                                      parseSendOrFunctionLiteral(=, expression)
+                                        parseSend(=, expression)
+                                          ensureIdentifier(=, expression)
+                                            listener: handleIdentifier(x, expression)
+                                          listener: handleNoTypeArguments(&)
+                                          parseArgumentsOpt(x)
+                                            listener: handleNoArguments(&)
+                                          listener: handleSend(x, &)
+                                  listener: beginBinaryExpression(&)
+                                  parsePrecedenceExpression(&, 12, true)
+                                    parseUnaryExpression(&, true)
+                                      parsePrimary(&, expression)
+                                        parseSendOrFunctionLiteral(&, expression)
+                                          parseSend(&, expression)
+                                            ensureIdentifier(&, expression)
+                                              listener: handleIdentifier(y, expression)
+                                            listener: handleNoTypeArguments(;)
+                                            parseArgumentsOpt(y)
+                                              listener: handleNoArguments(;)
+                                            listener: handleSend(y, ;)
+                                  listener: endBinaryExpression(&)
+                              listener: endVariableInitializer(=)
+                            listener: endInitializedIdentifier(z)
+                          ensureSemicolon(y)
+                          listener: endVariablesDeclaration(1, ;)
+                  notEofOrValue(}, return)
+                  parseStatement(;)
+                    parseStatementX(;)
+                      parseReturnStatement(;)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(z, expression)
+                                    listener: handleNoTypeArguments(;)
+                                    parseArgumentsOpt(z)
+                                      listener: handleNoArguments(;)
+                                    listener: handleSend(z, ;)
+                        ensureSemicolon(z)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(2, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, o, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, o)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(o)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(o, methodDeclaration)
+                parseQualifiedRestOpt(o, methodDeclarationContinuation)
+                parseMethodTypeVar(o)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(o, o, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(o, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseLiteralInt(=>)
+                              listener: handleLiteralInt(1)
+                        listener: beginBinaryExpression(+)
+                        parsePrecedenceExpression(+, 14, true)
+                          parseUnaryExpression(+, true)
+                            parsePrimary(+, expression)
+                              parseSendOrFunctionLiteral(+, expression)
+                                parseSend(+, expression)
+                                  ensureIdentifier(+, expression)
+                                    listener: handleIdentifier(x, expression)
+                                  listener: handleNoTypeArguments(and)
+                                  parseArgumentsOpt(x)
+                                    listener: handleNoArguments(and)
+                                  listener: handleSend(x, and)
+                          rewriter()
+                        listener: endBinaryExpression(+)
+                        rewriter()
+                        parsePrecedenceExpression(&, 12, true)
+                          parseUnaryExpression(&, true)
+                            parsePrimary(&, expression)
+                              parseSendOrFunctionLiteral(&, expression)
+                                parseSend(&, expression)
+                                  ensureIdentifier(&, expression)
+                                  parseArgumentsOpt(y)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                        reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
+                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                        rewriter()
+                        listener: beginBinaryExpression(&)
+                        parsePrecedenceExpression(&, 12, true)
+                          parseUnaryExpression(&, true)
+                            parsePrimary(&, expression)
+                              parseSendOrFunctionLiteral(&, expression)
+                                parseSend(&, expression)
+                                  ensureIdentifier(&, expression)
+                                    listener: handleIdentifier(y, expression)
+                                  listener: handleNoTypeArguments(+)
+                                  parseArgumentsOpt(y)
+                                    listener: handleNoArguments(+)
+                                  listener: handleSend(y, +)
+                          listener: beginBinaryExpression(+)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                                  listener: handleLiteralInt(3)
+                          listener: endBinaryExpression(+)
+                        listener: endBinaryExpression(&)
+                    ensureSemicolon(3)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(null, int, (, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, p, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, p)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(p)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(p, methodDeclaration)
+                parseQualifiedRestOpt(p, methodDeclarationContinuation)
+                parseMethodTypeVar(p)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(p, p, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(p, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseLiteralInt(=>)
+                              listener: handleLiteralInt(1)
+                        listener: beginBinaryExpression(+)
+                        parsePrecedenceExpression(+, 14, true)
+                          parseUnaryExpression(+, true)
+                            parsePrimary(+, expression)
+                              parseSendOrFunctionLiteral(+, expression)
+                                parseSend(+, expression)
+                                  ensureIdentifier(+, expression)
+                                    listener: handleIdentifier(x, expression)
+                                  listener: handleNoTypeArguments(&)
+                                  parseArgumentsOpt(x)
+                                    listener: handleNoArguments(&)
+                                  listener: handleSend(x, &)
+                        listener: endBinaryExpression(+)
+                        listener: beginBinaryExpression(&)
+                        parsePrecedenceExpression(&, 12, true)
+                          parseUnaryExpression(&, true)
+                            parsePrimary(&, expression)
+                              parseSendOrFunctionLiteral(&, expression)
+                                parseSend(&, expression)
+                                  ensureIdentifier(&, expression)
+                                    listener: handleIdentifier(y, expression)
+                                  listener: handleNoTypeArguments(+)
+                                  parseArgumentsOpt(y)
+                                    listener: handleNoArguments(+)
+                                  listener: handleSend(y, +)
+                          listener: beginBinaryExpression(+)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                                  listener: handleLiteralInt(3)
+                          listener: endBinaryExpression(+)
+                        listener: endBinaryExpression(&)
+                    ensureSemicolon(3)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(null, int, (, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, q, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, q)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(q)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(q, methodDeclaration)
+                parseQualifiedRestOpt(q, methodDeclarationContinuation)
+                parseMethodTypeVar(q)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(q, q, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(q, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseLiteralInt(return)
+                                  listener: handleLiteralInt(1)
+                            listener: beginBinaryExpression(+)
+                            parsePrecedenceExpression(+, 14, true)
+                              parseUnaryExpression(+, true)
+                                parsePrimary(+, expression)
+                                  parseSendOrFunctionLiteral(+, expression)
+                                    parseSend(+, expression)
+                                      ensureIdentifier(+, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(and)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(and)
+                                      listener: handleSend(x, and)
+                              rewriter()
+                            listener: endBinaryExpression(+)
+                            rewriter()
+                            parsePrecedenceExpression(&, 12, true)
+                              parseUnaryExpression(&, true)
+                                parsePrimary(&, expression)
+                                  parseSendOrFunctionLiteral(&, expression)
+                                    parseSend(&, expression)
+                                      ensureIdentifier(&, expression)
+                                      parseArgumentsOpt(y)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                            reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
+                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                            rewriter()
+                            listener: beginBinaryExpression(&)
+                            parsePrecedenceExpression(&, 12, true)
+                              parseUnaryExpression(&, true)
+                                parsePrimary(&, expression)
+                                  parseSendOrFunctionLiteral(&, expression)
+                                    parseSend(&, expression)
+                                      ensureIdentifier(&, expression)
+                                        listener: handleIdentifier(y, expression)
+                                      listener: handleNoTypeArguments(+)
+                                      parseArgumentsOpt(y)
+                                        listener: handleNoArguments(+)
+                                      listener: handleSend(y, +)
+                              listener: beginBinaryExpression(+)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                                      listener: handleLiteralInt(3)
+                              listener: endBinaryExpression(+)
+                            listener: endBinaryExpression(&)
+                        ensureSemicolon(3)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, r, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, r)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(r)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(r, methodDeclaration)
+                parseQualifiedRestOpt(r, methodDeclarationContinuation)
+                parseMethodTypeVar(r)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(r, r, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(r, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseLiteralInt(return)
+                                  listener: handleLiteralInt(1)
+                            listener: beginBinaryExpression(+)
+                            parsePrecedenceExpression(+, 14, true)
+                              parseUnaryExpression(+, true)
+                                parsePrimary(+, expression)
+                                  parseSendOrFunctionLiteral(+, expression)
+                                    parseSend(+, expression)
+                                      ensureIdentifier(+, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(&)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(&)
+                                      listener: handleSend(x, &)
+                            listener: endBinaryExpression(+)
+                            listener: beginBinaryExpression(&)
+                            parsePrecedenceExpression(&, 12, true)
+                              parseUnaryExpression(&, true)
+                                parsePrimary(&, expression)
+                                  parseSendOrFunctionLiteral(&, expression)
+                                    parseSend(&, expression)
+                                      ensureIdentifier(&, expression)
+                                        listener: handleIdentifier(y, expression)
+                                      listener: handleNoTypeArguments(+)
+                                      parseArgumentsOpt(y)
+                                        listener: handleNoArguments(+)
+                                      listener: handleSend(y, +)
+                              listener: beginBinaryExpression(+)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                                      listener: handleLiteralInt(3)
+                              listener: endBinaryExpression(+)
+                            listener: endBinaryExpression(&)
+                        ensureSemicolon(3)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, s)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(s)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              isReservedKeyword(()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, s, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, s)
+                listener: handleNoType(})
+                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
+                  listener: handleIdentifier(s, methodDeclaration)
+                parseQualifiedRestOpt(s, methodDeclarationContinuation)
+                parseMethodTypeVar(s)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(s, s, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(s, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, s)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(s)
+                        parseExpressionStatement({)
+                          parseExpression({)
+                            parsePrecedenceExpression({, 1, true)
+                              parseUnaryExpression({, true)
+                                parsePrimary({, expression)
+                                  parseSendOrFunctionLiteral({, expression)
+                                    looksLikeFunctionBody(;)
+                                    parseSend({, expression)
+                                      ensureIdentifier({, expression)
+                                        listener: handleIdentifier(s, expression)
+                                      listener: handleNoTypeArguments(()
+                                      parseArgumentsOpt(s)
+                                        parseArguments(s)
+                                          parseArgumentsRest(()
+                                            listener: beginArguments(()
+                                            parseExpression(()
+                                              parsePrecedenceExpression((, 1, true)
+                                                parseUnaryExpression((, true)
+                                                  parsePrimary((, expression)
+                                                    parseSendOrFunctionLiteral((, expression)
+                                                      parseSend((, expression)
+                                                        ensureIdentifier((, expression)
+                                                          listener: handleIdentifier(x, expression)
+                                                        listener: handleNoTypeArguments(and)
+                                                        parseArgumentsOpt(x)
+                                                          listener: handleNoArguments(and)
+                                                        listener: handleSend(x, and)
+                                                rewriter()
+                                                parsePrecedenceExpression(&, 12, true)
+                                                  parseUnaryExpression(&, true)
+                                                    parsePrimary(&, expression)
+                                                      parseSendOrFunctionLiteral(&, expression)
+                                                        parseSend(&, expression)
+                                                          ensureIdentifier(&, expression)
+                                                          parseArgumentsOpt(y)
+                                                reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
+                                                  listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                                                rewriter()
+                                                listener: beginBinaryExpression(&)
+                                                parsePrecedenceExpression(&, 12, true)
+                                                  parseUnaryExpression(&, true)
+                                                    parsePrimary(&, expression)
+                                                      parseSendOrFunctionLiteral(&, expression)
+                                                        parseSend(&, expression)
+                                                          ensureIdentifier(&, expression)
+                                                            listener: handleIdentifier(y, expression)
+                                                          listener: handleNoTypeArguments(,)
+                                                          parseArgumentsOpt(y)
+                                                            listener: handleNoArguments(,)
+                                                          listener: handleSend(y, ,)
+                                                listener: endBinaryExpression(&)
+                                            parseExpression(,)
+                                              parsePrecedenceExpression(,, 1, true)
+                                                parseUnaryExpression(,, true)
+                                                  parsePrimary(,, expression)
+                                                    parseSendOrFunctionLiteral(,, expression)
+                                                      parseSend(,, expression)
+                                                        ensureIdentifier(,, expression)
+                                                          listener: handleIdentifier(x, expression)
+                                                        listener: handleNoTypeArguments(and)
+                                                        parseArgumentsOpt(x)
+                                                          listener: handleNoArguments(and)
+                                                        listener: handleSend(x, and)
+                                                rewriter()
+                                                parsePrecedenceExpression(&, 12, true)
+                                                  parseUnaryExpression(&, true)
+                                                    parsePrimary(&, expression)
+                                                      parseSendOrFunctionLiteral(&, expression)
+                                                        parseSend(&, expression)
+                                                          ensureIdentifier(&, expression)
+                                                          parseArgumentsOpt(y)
+                                                reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
+                                                  listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                                                rewriter()
+                                                listener: beginBinaryExpression(&)
+                                                parsePrecedenceExpression(&, 12, true)
+                                                  parseUnaryExpression(&, true)
+                                                    parsePrimary(&, expression)
+                                                      parseSendOrFunctionLiteral(&, expression)
+                                                        parseSend(&, expression)
+                                                          ensureIdentifier(&, expression)
+                                                            listener: handleIdentifier(y, expression)
+                                                          listener: handleNoTypeArguments())
+                                                          parseArgumentsOpt(y)
+                                                            listener: handleNoArguments())
+                                                          listener: handleSend(y, ))
+                                                listener: endBinaryExpression(&)
+                                            listener: endArguments(2, (, ))
+                                      listener: handleSend(s, ;)
+                          ensureSemicolon())
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, s)
+                  parseStatement(;)
+                    parseStatementX(;)
+                      parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                        looksLikeLocalFunction(s)
+                        parseExpressionStatement(;)
+                          parseExpression(;)
+                            parsePrecedenceExpression(;, 1, true)
+                              parseUnaryExpression(;, true)
+                                parsePrimary(;, expression)
+                                  parseSendOrFunctionLiteral(;, expression)
+                                    looksLikeFunctionBody(;)
+                                    parseSend(;, expression)
+                                      ensureIdentifier(;, expression)
+                                        listener: handleIdentifier(s, expression)
+                                      listener: handleNoTypeArguments(()
+                                      parseArgumentsOpt(s)
+                                        parseArguments(s)
+                                          parseArgumentsRest(()
+                                            listener: beginArguments(()
+                                            parseExpression(()
+                                              parsePrecedenceExpression((, 1, true)
+                                                parseUnaryExpression((, true)
+                                                  parsePrimary((, expression)
+                                                    parseSendOrFunctionLiteral((, expression)
+                                                      parseSend((, expression)
+                                                        ensureIdentifier((, expression)
+                                                          listener: handleIdentifier(x, expression)
+                                                        listener: handleNoTypeArguments(&)
+                                                        parseArgumentsOpt(x)
+                                                          listener: handleNoArguments(&)
+                                                        listener: handleSend(x, &)
+                                                listener: beginBinaryExpression(&)
+                                                parsePrecedenceExpression(&, 12, true)
+                                                  parseUnaryExpression(&, true)
+                                                    parsePrimary(&, expression)
+                                                      parseSendOrFunctionLiteral(&, expression)
+                                                        parseSend(&, expression)
+                                                          ensureIdentifier(&, expression)
+                                                            listener: handleIdentifier(y, expression)
+                                                          listener: handleNoTypeArguments(,)
+                                                          parseArgumentsOpt(y)
+                                                            listener: handleNoArguments(,)
+                                                          listener: handleSend(y, ,)
+                                                listener: endBinaryExpression(&)
+                                            parseExpression(,)
+                                              parsePrecedenceExpression(,, 1, true)
+                                                parseUnaryExpression(,, true)
+                                                  parsePrimary(,, expression)
+                                                    parseSendOrFunctionLiteral(,, expression)
+                                                      parseSend(,, expression)
+                                                        ensureIdentifier(,, expression)
+                                                          listener: handleIdentifier(x, expression)
+                                                        listener: handleNoTypeArguments(&)
+                                                        parseArgumentsOpt(x)
+                                                          listener: handleNoArguments(&)
+                                                        listener: handleSend(x, &)
+                                                listener: beginBinaryExpression(&)
+                                                parsePrecedenceExpression(&, 12, true)
+                                                  parseUnaryExpression(&, true)
+                                                    parsePrimary(&, expression)
+                                                      parseSendOrFunctionLiteral(&, expression)
+                                                        parseSend(&, expression)
+                                                          ensureIdentifier(&, expression)
+                                                            listener: handleIdentifier(y, expression)
+                                                          listener: handleNoTypeArguments())
+                                                          parseArgumentsOpt(y)
+                                                            listener: handleNoArguments())
+                                                          listener: handleSend(y, ))
+                                                listener: endBinaryExpression(&)
+                                            listener: endArguments(2, (, ))
+                                      listener: handleSend(s, ;)
+                          ensureSemicolon())
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(2, {, })
+                listener: endClassMethod(null, s, (, null, })
+              listener: endMember()
+            notEofOrValue(}, Key)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(Key)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              isReservedKeyword(()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, Key, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, Key)
+                listener: handleNoType(})
+                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
+                  listener: handleIdentifier(Key, methodDeclaration)
+                parseQualifiedRestOpt(Key, methodDeclarationContinuation)
+                parseMethodTypeVar(Key)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(Key, Key, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(Key, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  parseInitializers(:)
+                    listener: beginInitializers(:)
+                    parseInitializer(:)
+                      listener: beginInitializer(foo)
+                      parseInitializerExpressionRest(:)
+                        parseExpression(:)
+                          parsePrecedenceExpression(:, 1, true)
+                            parseUnaryExpression(:, true)
+                              parsePrimary(:, expression)
+                                parseSendOrFunctionLiteral(:, expression)
+                                  parseSend(:, expression)
+                                    ensureIdentifier(:, expression)
+                                      listener: handleIdentifier(foo, expression)
+                                    listener: handleNoTypeArguments(=)
+                                    parseArgumentsOpt(foo)
+                                      listener: handleNoArguments(=)
+                                    listener: handleSend(foo, =)
+                            parsePrecedenceExpression(=, 1, true)
+                              parseUnaryExpression(=, true)
+                                parsePrimary(=, expression)
+                                  parseSendOrFunctionLiteral(=, expression)
+                                    parseSend(=, expression)
+                                      ensureIdentifier(=, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(and)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(and)
+                                      listener: handleSend(x, and)
+                              rewriter()
+                              parsePrecedenceExpression(&, 12, true)
+                                parseUnaryExpression(&, true)
+                                  parsePrimary(&, expression)
+                                    parseSendOrFunctionLiteral(&, expression)
+                                      parseSend(&, expression)
+                                        ensureIdentifier(&, expression)
+                                        parseArgumentsOpt(y)
+                              reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
+                                listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                              rewriter()
+                              listener: beginBinaryExpression(&)
+                              parsePrecedenceExpression(&, 12, true)
+                                parseUnaryExpression(&, true)
+                                  parsePrimary(&, expression)
+                                    parseSendOrFunctionLiteral(&, expression)
+                                      parseSend(&, expression)
+                                        ensureIdentifier(&, expression)
+                                          listener: handleIdentifier(y, expression)
+                                        listener: handleNoTypeArguments(,)
+                                        parseArgumentsOpt(y)
+                                          listener: handleNoArguments(,)
+                                        listener: handleSend(y, ,)
+                              listener: endBinaryExpression(&)
+                            listener: handleAssignmentExpression(=)
+                        listener: endInitializer(,)
+                    parseInitializer(,)
+                      listener: beginInitializer(bar)
+                      parseInitializerExpressionRest(,)
+                        parseExpression(,)
+                          parsePrecedenceExpression(,, 1, true)
+                            parseUnaryExpression(,, true)
+                              parsePrimary(,, expression)
+                                parseSendOrFunctionLiteral(,, expression)
+                                  parseSend(,, expression)
+                                    ensureIdentifier(,, expression)
+                                      listener: handleIdentifier(bar, expression)
+                                    listener: handleNoTypeArguments(=)
+                                    parseArgumentsOpt(bar)
+                                      listener: handleNoArguments(=)
+                                    listener: handleSend(bar, =)
+                            parsePrecedenceExpression(=, 1, true)
+                              parseUnaryExpression(=, true)
+                                parsePrimary(=, expression)
+                                  parseSendOrFunctionLiteral(=, expression)
+                                    parseSend(=, expression)
+                                      ensureIdentifier(=, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(and)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(and)
+                                      listener: handleSend(x, and)
+                              rewriter()
+                              parsePrecedenceExpression(&, 12, true)
+                                parseUnaryExpression(&, true)
+                                  parsePrimary(&, expression)
+                                    parseSendOrFunctionLiteral(&, expression)
+                                      parseSend(&, expression)
+                                        ensureIdentifier(&, expression)
+                                        parseArgumentsOpt(y)
+                              reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
+                                listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                              rewriter()
+                              listener: beginBinaryExpression(&)
+                              parsePrecedenceExpression(&, 12, true)
+                                parseUnaryExpression(&, true)
+                                  parsePrimary(&, expression)
+                                    parseSendOrFunctionLiteral(&, expression)
+                                      parseSend(&, expression)
+                                        ensureIdentifier(&, expression)
+                                          listener: handleIdentifier(y, expression)
+                                        listener: handleNoTypeArguments({)
+                                        parseArgumentsOpt(y)
+                                          listener: handleNoArguments({)
+                                        listener: handleSend(y, {)
+                              listener: endBinaryExpression(&)
+                            listener: handleAssignmentExpression(=)
+                        listener: endInitializer({)
+                    listener: endInitializers(2, :, {)
+                parseAsyncModifierOpt(y)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(y, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, print)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(print)
+                        parseExpressionStatement({)
+                          parseExpression({)
+                            parsePrecedenceExpression({, 1, true)
+                              parseUnaryExpression({, true)
+                                parsePrimary({, expression)
+                                  parseSendOrFunctionLiteral({, expression)
+                                    looksLikeFunctionBody(;)
+                                    parseSend({, expression)
+                                      ensureIdentifier({, expression)
+                                        listener: handleIdentifier(print, expression)
+                                      listener: handleNoTypeArguments(()
+                                      parseArgumentsOpt(print)
+                                        parseArguments(print)
+                                          parseArgumentsRest(()
+                                            listener: beginArguments(()
+                                            parseExpression(()
+                                              parsePrecedenceExpression((, 1, true)
+                                                parseUnaryExpression((, true)
+                                                  parsePrimary((, expression)
+                                                    parseLiteralString(()
+                                                      parseSingleLiteralString(()
+                                                        listener: beginLiteralString("hello )
+                                                        parseExpression(${)
+                                                          parsePrecedenceExpression(${, 1, true)
+                                                            parseUnaryExpression(${, true)
+                                                              parsePrimary(${, expression)
+                                                                parseSendOrFunctionLiteral(${, expression)
+                                                                  parseSend(${, expression)
+                                                                    ensureIdentifier(${, expression)
+                                                                      listener: handleIdentifier(x, expression)
+                                                                    listener: handleNoTypeArguments(and)
+                                                                    parseArgumentsOpt(x)
+                                                                      listener: handleNoArguments(and)
+                                                                    listener: handleSend(x, and)
+                                                            rewriter()
+                                                            parsePrecedenceExpression(&, 12, true)
+                                                              parseUnaryExpression(&, true)
+                                                                parsePrimary(&, expression)
+                                                                  parseSendOrFunctionLiteral(&, expression)
+                                                                    parseSend(&, expression)
+                                                                      ensureIdentifier(&, expression)
+                                                                      parseArgumentsOpt(y)
+                                                            reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
+                                                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
+                                                            rewriter()
+                                                            listener: beginBinaryExpression(&)
+                                                            parsePrecedenceExpression(&, 12, true)
+                                                              parseUnaryExpression(&, true)
+                                                                parsePrimary(&, expression)
+                                                                  parseSendOrFunctionLiteral(&, expression)
+                                                                    parseSend(&, expression)
+                                                                      ensureIdentifier(&, expression)
+                                                                        listener: handleIdentifier(y, expression)
+                                                                      listener: handleNoTypeArguments(})
+                                                                      parseArgumentsOpt(y)
+                                                                        listener: handleNoArguments(})
+                                                                      listener: handleSend(y, })
+                                                            listener: endBinaryExpression(&)
+                                                        listener: handleInterpolationExpression(${, })
+                                                        parseStringPart(})
+                                                          listener: handleStringPart(")
+                                                        listener: endLiteralString(1, ))
+                                            listener: endArguments(1, (, ))
+                                      listener: handleSend(print, ;)
+                          ensureSemicolon())
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassConstructor(null, Key, (, :, })
+              listener: endMember()
+            notEofOrValue(}, Key)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(Key)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              isReservedKeyword(()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, Key, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, Key)
+                listener: handleNoType(})
+                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
+                  listener: handleIdentifier(Key, methodDeclaration)
+                parseQualifiedRestOpt(Key, methodDeclarationContinuation)
+                parseMethodTypeVar(Key)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(Key, Key, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(Key, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  parseInitializers(:)
+                    listener: beginInitializers(:)
+                    parseInitializer(:)
+                      listener: beginInitializer(foo)
+                      parseInitializerExpressionRest(:)
+                        parseExpression(:)
+                          parsePrecedenceExpression(:, 1, true)
+                            parseUnaryExpression(:, true)
+                              parsePrimary(:, expression)
+                                parseSendOrFunctionLiteral(:, expression)
+                                  parseSend(:, expression)
+                                    ensureIdentifier(:, expression)
+                                      listener: handleIdentifier(foo, expression)
+                                    listener: handleNoTypeArguments(=)
+                                    parseArgumentsOpt(foo)
+                                      listener: handleNoArguments(=)
+                                    listener: handleSend(foo, =)
+                            parsePrecedenceExpression(=, 1, true)
+                              parseUnaryExpression(=, true)
+                                parsePrimary(=, expression)
+                                  parseSendOrFunctionLiteral(=, expression)
+                                    parseSend(=, expression)
+                                      ensureIdentifier(=, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(&)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(&)
+                                      listener: handleSend(x, &)
+                              listener: beginBinaryExpression(&)
+                              parsePrecedenceExpression(&, 12, true)
+                                parseUnaryExpression(&, true)
+                                  parsePrimary(&, expression)
+                                    parseSendOrFunctionLiteral(&, expression)
+                                      parseSend(&, expression)
+                                        ensureIdentifier(&, expression)
+                                          listener: handleIdentifier(y, expression)
+                                        listener: handleNoTypeArguments(,)
+                                        parseArgumentsOpt(y)
+                                          listener: handleNoArguments(,)
+                                        listener: handleSend(y, ,)
+                              listener: endBinaryExpression(&)
+                            listener: handleAssignmentExpression(=)
+                        listener: endInitializer(,)
+                    parseInitializer(,)
+                      listener: beginInitializer(bar)
+                      parseInitializerExpressionRest(,)
+                        parseExpression(,)
+                          parsePrecedenceExpression(,, 1, true)
+                            parseUnaryExpression(,, true)
+                              parsePrimary(,, expression)
+                                parseSendOrFunctionLiteral(,, expression)
+                                  parseSend(,, expression)
+                                    ensureIdentifier(,, expression)
+                                      listener: handleIdentifier(bar, expression)
+                                    listener: handleNoTypeArguments(=)
+                                    parseArgumentsOpt(bar)
+                                      listener: handleNoArguments(=)
+                                    listener: handleSend(bar, =)
+                            parsePrecedenceExpression(=, 1, true)
+                              parseUnaryExpression(=, true)
+                                parsePrimary(=, expression)
+                                  parseSendOrFunctionLiteral(=, expression)
+                                    parseSend(=, expression)
+                                      ensureIdentifier(=, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(&)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(&)
+                                      listener: handleSend(x, &)
+                              listener: beginBinaryExpression(&)
+                              parsePrecedenceExpression(&, 12, true)
+                                parseUnaryExpression(&, true)
+                                  parsePrimary(&, expression)
+                                    parseSendOrFunctionLiteral(&, expression)
+                                      parseSend(&, expression)
+                                        ensureIdentifier(&, expression)
+                                          listener: handleIdentifier(y, expression)
+                                        listener: handleNoTypeArguments({)
+                                        parseArgumentsOpt(y)
+                                          listener: handleNoArguments({)
+                                        listener: handleSend(y, {)
+                              listener: endBinaryExpression(&)
+                            listener: handleAssignmentExpression(=)
+                        listener: endInitializer({)
+                    listener: endInitializers(2, :, {)
+                parseAsyncModifierOpt(y)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(y, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, print)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(print)
+                        parseExpressionStatement({)
+                          parseExpression({)
+                            parsePrecedenceExpression({, 1, true)
+                              parseUnaryExpression({, true)
+                                parsePrimary({, expression)
+                                  parseSendOrFunctionLiteral({, expression)
+                                    looksLikeFunctionBody(;)
+                                    parseSend({, expression)
+                                      ensureIdentifier({, expression)
+                                        listener: handleIdentifier(print, expression)
+                                      listener: handleNoTypeArguments(()
+                                      parseArgumentsOpt(print)
+                                        parseArguments(print)
+                                          parseArgumentsRest(()
+                                            listener: beginArguments(()
+                                            parseExpression(()
+                                              parsePrecedenceExpression((, 1, true)
+                                                parseUnaryExpression((, true)
+                                                  parsePrimary((, expression)
+                                                    parseLiteralString(()
+                                                      parseSingleLiteralString(()
+                                                        listener: beginLiteralString("hello )
+                                                        parseExpression(${)
+                                                          parsePrecedenceExpression(${, 1, true)
+                                                            parseUnaryExpression(${, true)
+                                                              parsePrimary(${, expression)
+                                                                parseSendOrFunctionLiteral(${, expression)
+                                                                  parseSend(${, expression)
+                                                                    ensureIdentifier(${, expression)
+                                                                      listener: handleIdentifier(x, expression)
+                                                                    listener: handleNoTypeArguments(&)
+                                                                    parseArgumentsOpt(x)
+                                                                      listener: handleNoArguments(&)
+                                                                    listener: handleSend(x, &)
+                                                            listener: beginBinaryExpression(&)
+                                                            parsePrecedenceExpression(&, 12, true)
+                                                              parseUnaryExpression(&, true)
+                                                                parsePrimary(&, expression)
+                                                                  parseSendOrFunctionLiteral(&, expression)
+                                                                    parseSend(&, expression)
+                                                                      ensureIdentifier(&, expression)
+                                                                        listener: handleIdentifier(y, expression)
+                                                                      listener: handleNoTypeArguments(})
+                                                                      parseArgumentsOpt(y)
+                                                                        listener: handleNoArguments(})
+                                                                      listener: handleSend(y, })
+                                                            listener: endBinaryExpression(&)
+                                                        listener: handleInterpolationExpression(${, })
+                                                        parseStringPart(})
+                                                          listener: handleStringPart(")
+                                                        listener: endLiteralString(1, ))
+                                            listener: endArguments(1, (, ))
+                                      listener: handleSend(print, ;)
+                          ensureSemicolon())
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassConstructor(null, Key, (, :, })
+              listener: endMember()
+            notEofOrValue(}, not_currently_working)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(not_currently_working)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              isReservedKeyword(()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, not_currently_working, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, not_currently_working)
+                listener: handleNoType(})
+                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
+                  listener: handleIdentifier(not_currently_working, methodDeclaration)
+                parseQualifiedRestOpt(not_currently_working, methodDeclarationContinuation)
+                parseMethodTypeVar(not_currently_working)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(not_currently_working, not_currently_working, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(not_currently_working, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, x)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(and)
+                        listener: beginMetadataStar(x)
+                        listener: endMetadataStar(0)
+                        listener: handleIdentifier(x, typeReference)
+                        listener: handleNoTypeArguments(and)
+                        listener: handleType(x, null)
+                        listener: beginVariablesDeclaration(and, null, null)
+                        parseVariablesDeclarationRest(x, true)
+                          parseOptionallyInitializedIdentifier(x)
+                            ensureIdentifier(x, localVariableDeclaration)
+                              listener: handleIdentifier(and, localVariableDeclaration)
+                            listener: beginInitializedIdentifier(and)
+                            parseVariableInitializerOpt(and)
+                              listener: handleNoVariableInitializer(and)
+                            listener: endInitializedIdentifier(and)
+                          ensureSemicolon(and)
+                            reportRecoverableError(and, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
+                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], and, and)
+                            rewriter()
+                          listener: endVariablesDeclaration(1, ;)
+                  notEofOrValue(}, y)
+                  parseStatement(;)
+                    parseStatementX(;)
+                      parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                        looksLikeLocalFunction(y)
+                        parseExpressionStatement(;)
+                          parseExpression(;)
+                            parsePrecedenceExpression(;, 1, true)
+                              parseUnaryExpression(;, true)
+                                parsePrimary(;, expression)
+                                  parseSendOrFunctionLiteral(;, expression)
+                                    parseSend(;, expression)
+                                      ensureIdentifier(;, expression)
+                                        listener: handleIdentifier(y, expression)
+                                      listener: handleNoTypeArguments(;)
+                                      parseArgumentsOpt(y)
+                                        listener: handleNoArguments(;)
+                                      listener: handleSend(y, ;)
+                          ensureSemicolon(y)
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, x)
+                  parseStatement(;)
+                    parseStatementX(;)
+                      parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                        looksLikeLocalFunction(x)
+                        parseExpressionStatement(;)
+                          parseExpression(;)
+                            parsePrecedenceExpression(;, 1, true)
+                              parseUnaryExpression(;, true)
+                                parsePrimary(;, expression)
+                                  parseSendOrFunctionLiteral(;, expression)
+                                    parseSend(;, expression)
+                                      ensureIdentifier(;, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(&)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(&)
+                                      listener: handleSend(x, &)
+                              listener: beginBinaryExpression(&)
+                              parsePrecedenceExpression(&, 12, true)
+                                parseUnaryExpression(&, true)
+                                  parsePrimary(&, expression)
+                                    parseSendOrFunctionLiteral(&, expression)
+                                      parseSend(&, expression)
+                                        ensureIdentifier(&, expression)
+                                          listener: handleIdentifier(y, expression)
+                                        listener: handleNoTypeArguments(;)
+                                        parseArgumentsOpt(y)
+                                          listener: handleNoArguments(;)
+                                        listener: handleSend(y, ;)
+                              listener: endBinaryExpression(&)
+                          ensureSemicolon(y)
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(3, {, })
+                listener: endClassMethod(null, not_currently_working, (, null, })
+              listener: endMember()
+            notEofOrValue(}, })
+            listener: endClassOrMixinBody(DeclarationKind.Class, 22, {, })
+          listener: endClassDeclaration(abstract, })
+  listener: endTopLevelDeclaration()
+  reportAllErrorTokens(abstract)
+  listener: endCompilationUnit(1, )
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.parser.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.parser.expect
new file mode 100644
index 0000000..16ee9fd
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.parser.expect
@@ -0,0 +1,87 @@
+NOTICE: Stream was rewritten by parser!
+
+abstract class Key {
+int get a => runtimeType.hashCode & null.hashCode;
+int get b => runtimeType.hashCode & null.hashCode;
+int get c { return runtimeType.hashCode & null.hashCode; }
+int get d { return runtimeType.hashCode & null.hashCode; }
+
+int get e => 1 + runtimeType.hashCode & null.hashCode + 3;
+int get f => 1 + runtimeType.hashCode & null.hashCode + 3;
+int get g { return 1 + runtimeType.hashCode & null.hashCode + 3; }
+int get h { return 1 + runtimeType.hashCode & null.hashCode + 3; }
+
+int i(int x, int y) => x & y;
+int j(int x, int y) => x & y;
+int k(int x, int y) { return x & y; }
+int l(int x, int y) { return x & y; }
+int m(int x, int y) { int z = x & y; return z; }
+int n(int x, int y) { int z = x & y; return z; }
+
+int o(int x, int y) => 1 + x & y + 3;
+int p(int x, int y) => 1 + x & y + 3;
+int q(int x, int y) { return 1 + x & y + 3; }
+int r(int x, int y) { return 1 + x & y + 3; }
+
+s(int x, int y) {
+s(x & y, x & y);
+s(x & y, x & y);
+}
+
+Key(int x, int y) : foo = x & y, bar = x & y {
+print("hello ${x & y}");
+}
+
+Key(int x, int y) : foo = x & y, bar = x & y {
+print("hello ${x & y}");
+}
+
+not_currently_working(int x, int y) {
+x and ;y;
+x & y;
+}
+}
+
+
+abstract[KeywordToken] class[KeywordToken] Key[StringToken] {[BeginToken]
+int[StringToken] get[KeywordToken] a[StringToken] =>[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] &[ReplacementToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] b[StringToken] =>[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] &[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] c[StringToken] {[BeginToken] return[KeywordToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] &[ReplacementToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] get[KeywordToken] d[StringToken] {[BeginToken] return[KeywordToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] &[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] get[KeywordToken] e[StringToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] &[ReplacementToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] f[StringToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] &[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] g[StringToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] &[ReplacementToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] get[KeywordToken] h[StringToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] &[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] i[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] x[StringToken] &[ReplacementToken] y[StringToken];[SimpleToken]
+int[StringToken] j[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] x[StringToken] &[SimpleToken] y[StringToken];[SimpleToken]
+int[StringToken] k[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] x[StringToken] &[ReplacementToken] y[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] l[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] x[StringToken] &[SimpleToken] y[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] m[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] int[StringToken] z[StringToken] =[SimpleToken] x[StringToken] &[ReplacementToken] y[StringToken];[SimpleToken] return[KeywordToken] z[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] n[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] int[StringToken] z[StringToken] =[SimpleToken] x[StringToken] &[SimpleToken] y[StringToken];[SimpleToken] return[KeywordToken] z[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] o[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] x[StringToken] &[ReplacementToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] p[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] x[StringToken] &[SimpleToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] q[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] x[StringToken] &[ReplacementToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] r[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] x[StringToken] &[SimpleToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+
+s[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken]
+s[StringToken]([BeginToken]x[StringToken] &[ReplacementToken] y[StringToken],[SimpleToken] x[StringToken] &[ReplacementToken] y[StringToken])[SimpleToken];[SimpleToken]
+s[StringToken]([BeginToken]x[StringToken] &[SimpleToken] y[StringToken],[SimpleToken] x[StringToken] &[SimpleToken] y[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+Key[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] :[SimpleToken] foo[StringToken] =[SimpleToken] x[StringToken] &[ReplacementToken] y[StringToken],[SimpleToken] bar[StringToken] =[SimpleToken] x[StringToken] &[ReplacementToken] y[StringToken] {[BeginToken]
+print[StringToken]([BeginToken]"hello [StringToken]${[BeginToken]x[StringToken] &[ReplacementToken] y[StringToken]}[SimpleToken]"[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+Key[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] :[SimpleToken] foo[StringToken] =[SimpleToken] x[StringToken] &[SimpleToken] y[StringToken],[SimpleToken] bar[StringToken] =[SimpleToken] x[StringToken] &[SimpleToken] y[StringToken] {[BeginToken]
+print[StringToken]([BeginToken]"hello [StringToken]${[BeginToken]x[StringToken] &[SimpleToken] y[StringToken]}[SimpleToken]"[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+not_currently_working[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken]
+x[StringToken] and[StringToken] ;[SyntheticToken]y[StringToken];[SimpleToken]
+x[StringToken] &[SimpleToken] y[StringToken];[SimpleToken]
+}[SimpleToken]
+}[SimpleToken]
+[SimpleToken]
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.scanner.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.scanner.expect
new file mode 100644
index 0000000..5b180a3
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.scanner.expect
@@ -0,0 +1,85 @@
+abstract class Key {
+int get a => runtimeType.hashCode and null.hashCode;
+int get b => runtimeType.hashCode & null.hashCode;
+int get c { return runtimeType.hashCode and null.hashCode; }
+int get d { return runtimeType.hashCode & null.hashCode; }
+
+int get e => 1 + runtimeType.hashCode and null.hashCode + 3;
+int get f => 1 + runtimeType.hashCode & null.hashCode + 3;
+int get g { return 1 + runtimeType.hashCode and null.hashCode + 3; }
+int get h { return 1 + runtimeType.hashCode & null.hashCode + 3; }
+
+int i(int x, int y) => x and y;
+int j(int x, int y) => x & y;
+int k(int x, int y) { return x and y; }
+int l(int x, int y) { return x & y; }
+int m(int x, int y) { int z = x and y; return z; }
+int n(int x, int y) { int z = x & y; return z; }
+
+int o(int x, int y) => 1 + x and y + 3;
+int p(int x, int y) => 1 + x & y + 3;
+int q(int x, int y) { return 1 + x and y + 3; }
+int r(int x, int y) { return 1 + x & y + 3; }
+
+s(int x, int y) {
+s(x and y, x and y);
+s(x & y, x & y);
+}
+
+Key(int x, int y) : foo = x and y, bar = x and y {
+print("hello ${x and y}");
+}
+
+Key(int x, int y) : foo = x & y, bar = x & y {
+print("hello ${x & y}");
+}
+
+not_currently_working(int x, int y) {
+x and y;
+x & y;
+}
+}
+
+
+abstract[KeywordToken] class[KeywordToken] Key[StringToken] {[BeginToken]
+int[StringToken] get[KeywordToken] a[StringToken] =>[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] and[StringToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] b[StringToken] =>[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] &[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] c[StringToken] {[BeginToken] return[KeywordToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] and[StringToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] get[KeywordToken] d[StringToken] {[BeginToken] return[KeywordToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] &[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] get[KeywordToken] e[StringToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] and[StringToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] f[StringToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] &[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] g[StringToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] and[StringToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] get[KeywordToken] h[StringToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] &[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] i[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] x[StringToken] and[StringToken] y[StringToken];[SimpleToken]
+int[StringToken] j[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] x[StringToken] &[SimpleToken] y[StringToken];[SimpleToken]
+int[StringToken] k[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] x[StringToken] and[StringToken] y[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] l[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] x[StringToken] &[SimpleToken] y[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] m[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] int[StringToken] z[StringToken] =[SimpleToken] x[StringToken] and[StringToken] y[StringToken];[SimpleToken] return[KeywordToken] z[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] n[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] int[StringToken] z[StringToken] =[SimpleToken] x[StringToken] &[SimpleToken] y[StringToken];[SimpleToken] return[KeywordToken] z[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] o[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] x[StringToken] and[StringToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] p[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] x[StringToken] &[SimpleToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] q[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] x[StringToken] and[StringToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] r[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] x[StringToken] &[SimpleToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+
+s[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken]
+s[StringToken]([BeginToken]x[StringToken] and[StringToken] y[StringToken],[SimpleToken] x[StringToken] and[StringToken] y[StringToken])[SimpleToken];[SimpleToken]
+s[StringToken]([BeginToken]x[StringToken] &[SimpleToken] y[StringToken],[SimpleToken] x[StringToken] &[SimpleToken] y[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+Key[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] :[SimpleToken] foo[StringToken] =[SimpleToken] x[StringToken] and[StringToken] y[StringToken],[SimpleToken] bar[StringToken] =[SimpleToken] x[StringToken] and[StringToken] y[StringToken] {[BeginToken]
+print[StringToken]([BeginToken]"hello [StringToken]${[BeginToken]x[StringToken] and[StringToken] y[StringToken]}[SimpleToken]"[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+Key[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] :[SimpleToken] foo[StringToken] =[SimpleToken] x[StringToken] &[SimpleToken] y[StringToken],[SimpleToken] bar[StringToken] =[SimpleToken] x[StringToken] &[SimpleToken] y[StringToken] {[BeginToken]
+print[StringToken]([BeginToken]"hello [StringToken]${[BeginToken]x[StringToken] &[SimpleToken] y[StringToken]}[SimpleToken]"[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+not_currently_working[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken]
+x[StringToken] and[StringToken] y[StringToken];[SimpleToken]
+x[StringToken] &[SimpleToken] y[StringToken];[SimpleToken]
+}[SimpleToken]
+}[SimpleToken]
+[SimpleToken]
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart b/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart
new file mode 100644
index 0000000..f5fbb1c
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart
@@ -0,0 +1,41 @@
+abstract class Key {
+  int get a => runtimeType.hashCode or null.hashCode;
+  int get b => runtimeType.hashCode | null.hashCode;
+  int get c { return runtimeType.hashCode or null.hashCode; }
+  int get d { return runtimeType.hashCode | null.hashCode; }
+
+  int get e => 1 + runtimeType.hashCode or null.hashCode + 3;
+  int get f => 1 + runtimeType.hashCode | null.hashCode + 3;
+  int get g { return 1 + runtimeType.hashCode or null.hashCode + 3; }
+  int get h { return 1 + runtimeType.hashCode | null.hashCode + 3; }
+
+  int i(int x, int y) => x or y;
+  int j(int x, int y) => x | y;
+  int k(int x, int y) { return x or y; }
+  int l(int x, int y) { return x | y; }
+  int m(int x, int y) { int z =  x or y; return z; }
+  int n(int x, int y) { int z = x | y; return z; }
+
+  int o(int x, int y) => 1 + x or y + 3;
+  int p(int x, int y) => 1 + x | y + 3;
+  int q(int x, int y) { return 1 + x or y + 3; }
+  int r(int x, int y) { return 1 + x | y + 3; }
+
+  s(int x, int y) {
+    s(x or y, x or y);
+    s(x | y, x | y);
+  }
+
+  Key(int x, int y) : foo = x or y, bar = x or y {
+    print("hello ${x or y}");
+  }
+
+  Key(int x, int y) : foo = x | y, bar = x | y {
+    print("hello ${x | y}");
+  }
+
+  not_currently_working(int x, int y) {
+    x or y;
+    x | y;
+  }
+}
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.expect
new file mode 100644
index 0000000..9080b89
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.expect
@@ -0,0 +1,1221 @@
+Problems reported:
+
+parser/error_recovery/issue_26810_or:2:37: Binary operator 'or' is written as '|' instead of the written out word.
+  int get a => runtimeType.hashCode or null.hashCode;
+                                    ^^
+
+parser/error_recovery/issue_26810_or:4:43: Binary operator 'or' is written as '|' instead of the written out word.
+  int get c { return runtimeType.hashCode or null.hashCode; }
+                                          ^^
+
+parser/error_recovery/issue_26810_or:7:41: Binary operator 'or' is written as '|' instead of the written out word.
+  int get e => 1 + runtimeType.hashCode or null.hashCode + 3;
+                                        ^^
+
+parser/error_recovery/issue_26810_or:9:47: Binary operator 'or' is written as '|' instead of the written out word.
+  int get g { return 1 + runtimeType.hashCode or null.hashCode + 3; }
+                                              ^^
+
+parser/error_recovery/issue_26810_or:12:28: Binary operator 'or' is written as '|' instead of the written out word.
+  int i(int x, int y) => x or y;
+                           ^^
+
+parser/error_recovery/issue_26810_or:14:34: Binary operator 'or' is written as '|' instead of the written out word.
+  int k(int x, int y) { return x or y; }
+                                 ^^
+
+parser/error_recovery/issue_26810_or:16:36: Binary operator 'or' is written as '|' instead of the written out word.
+  int m(int x, int y) { int z =  x or y; return z; }
+                                   ^^
+
+parser/error_recovery/issue_26810_or:19:32: Binary operator 'or' is written as '|' instead of the written out word.
+  int o(int x, int y) => 1 + x or y + 3;
+                               ^^
+
+parser/error_recovery/issue_26810_or:21:38: Binary operator 'or' is written as '|' instead of the written out word.
+  int q(int x, int y) { return 1 + x or y + 3; }
+                                     ^^
+
+parser/error_recovery/issue_26810_or:25:9: Binary operator 'or' is written as '|' instead of the written out word.
+    s(x or y, x or y);
+        ^^
+
+parser/error_recovery/issue_26810_or:25:17: Binary operator 'or' is written as '|' instead of the written out word.
+    s(x or y, x or y);
+                ^^
+
+parser/error_recovery/issue_26810_or:29:31: Binary operator 'or' is written as '|' instead of the written out word.
+  Key(int x, int y) : foo = x or y, bar = x or y {
+                              ^^
+
+parser/error_recovery/issue_26810_or:29:45: Binary operator 'or' is written as '|' instead of the written out word.
+  Key(int x, int y) : foo = x or y, bar = x or y {
+                                            ^^
+
+parser/error_recovery/issue_26810_or:30:22: Binary operator 'or' is written as '|' instead of the written out word.
+    print("hello ${x or y}");
+                     ^^
+
+parser/error_recovery/issue_26810_or:38:7: Expected ';' after this.
+    x or y;
+      ^^
+
+beginCompilationUnit(abstract)
+  beginMetadataStar(abstract)
+  endMetadataStar(0)
+  beginClassOrNamedMixinApplicationPrelude(abstract)
+    handleIdentifier(Key, classOrMixinDeclaration)
+    handleNoTypeVariables({)
+    beginClassDeclaration(abstract, abstract, Key)
+      handleNoType(Key)
+      handleClassExtends(null, 1)
+      handleClassNoWithClause()
+      handleClassOrMixinImplements(null, 0)
+      handleClassHeader(abstract, class, null)
+      beginClassOrMixinBody(DeclarationKind.Class, {)
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, a)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(a, methodDeclaration)
+            handleNoTypeVariables(=>)
+            handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleIdentifier(runtimeType, expression)
+            handleNoTypeArguments(.)
+            handleNoArguments(.)
+            handleSend(runtimeType, .)
+            handleIdentifier(hashCode, expressionContinuation)
+            handleNoTypeArguments(or)
+            handleNoArguments(or)
+            handleSend(hashCode, or)
+            handleEndingBinaryExpression(.)
+            handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+            beginBinaryExpression(|)
+              handleLiteralNull(null)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(hashCode, ;)
+              handleEndingBinaryExpression(.)
+            endBinaryExpression(|)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(get, int, =>, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, b)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(b, methodDeclaration)
+            handleNoTypeVariables(=>)
+            handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleIdentifier(runtimeType, expression)
+            handleNoTypeArguments(.)
+            handleNoArguments(.)
+            handleSend(runtimeType, .)
+            handleIdentifier(hashCode, expressionContinuation)
+            handleNoTypeArguments(|)
+            handleNoArguments(|)
+            handleSend(hashCode, |)
+            handleEndingBinaryExpression(.)
+            beginBinaryExpression(|)
+              handleLiteralNull(null)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(hashCode, ;)
+              handleEndingBinaryExpression(.)
+            endBinaryExpression(|)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(get, int, =>, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, c)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(c, methodDeclaration)
+            handleNoTypeVariables({)
+            handleNoFormalParameters({, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleIdentifier(runtimeType, expression)
+                handleNoTypeArguments(.)
+                handleNoArguments(.)
+                handleSend(runtimeType, .)
+                handleIdentifier(hashCode, expressionContinuation)
+                handleNoTypeArguments(or)
+                handleNoArguments(or)
+                handleSend(hashCode, or)
+                handleEndingBinaryExpression(.)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                beginBinaryExpression(|)
+                  handleLiteralNull(null)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(;)
+                  handleNoArguments(;)
+                  handleSend(hashCode, ;)
+                  handleEndingBinaryExpression(.)
+                endBinaryExpression(|)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(get, int, {, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, d)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(d, methodDeclaration)
+            handleNoTypeVariables({)
+            handleNoFormalParameters({, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleIdentifier(runtimeType, expression)
+                handleNoTypeArguments(.)
+                handleNoArguments(.)
+                handleSend(runtimeType, .)
+                handleIdentifier(hashCode, expressionContinuation)
+                handleNoTypeArguments(|)
+                handleNoArguments(|)
+                handleSend(hashCode, |)
+                handleEndingBinaryExpression(.)
+                beginBinaryExpression(|)
+                  handleLiteralNull(null)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(;)
+                  handleNoArguments(;)
+                  handleSend(hashCode, ;)
+                  handleEndingBinaryExpression(.)
+                endBinaryExpression(|)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(get, int, {, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, e)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(e, methodDeclaration)
+            handleNoTypeVariables(=>)
+            handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleLiteralInt(1)
+            beginBinaryExpression(+)
+              handleIdentifier(runtimeType, expression)
+              handleNoTypeArguments(.)
+              handleNoArguments(.)
+              handleSend(runtimeType, .)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(or)
+              handleNoArguments(or)
+              handleSend(hashCode, or)
+              handleEndingBinaryExpression(.)
+            endBinaryExpression(+)
+            handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+            beginBinaryExpression(|)
+              handleLiteralNull(null)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(+)
+              handleNoArguments(+)
+              handleSend(hashCode, +)
+              handleEndingBinaryExpression(.)
+              beginBinaryExpression(+)
+                handleLiteralInt(3)
+              endBinaryExpression(+)
+            endBinaryExpression(|)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(get, int, =>, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, f)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(f, methodDeclaration)
+            handleNoTypeVariables(=>)
+            handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleLiteralInt(1)
+            beginBinaryExpression(+)
+              handleIdentifier(runtimeType, expression)
+              handleNoTypeArguments(.)
+              handleNoArguments(.)
+              handleSend(runtimeType, .)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(|)
+              handleNoArguments(|)
+              handleSend(hashCode, |)
+              handleEndingBinaryExpression(.)
+            endBinaryExpression(+)
+            beginBinaryExpression(|)
+              handleLiteralNull(null)
+              handleIdentifier(hashCode, expressionContinuation)
+              handleNoTypeArguments(+)
+              handleNoArguments(+)
+              handleSend(hashCode, +)
+              handleEndingBinaryExpression(.)
+              beginBinaryExpression(+)
+                handleLiteralInt(3)
+              endBinaryExpression(+)
+            endBinaryExpression(|)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(get, int, =>, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, g)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(g, methodDeclaration)
+            handleNoTypeVariables({)
+            handleNoFormalParameters({, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleLiteralInt(1)
+                beginBinaryExpression(+)
+                  handleIdentifier(runtimeType, expression)
+                  handleNoTypeArguments(.)
+                  handleNoArguments(.)
+                  handleSend(runtimeType, .)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(or)
+                  handleNoArguments(or)
+                  handleSend(hashCode, or)
+                  handleEndingBinaryExpression(.)
+                endBinaryExpression(+)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                beginBinaryExpression(|)
+                  handleLiteralNull(null)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(+)
+                  handleNoArguments(+)
+                  handleSend(hashCode, +)
+                  handleEndingBinaryExpression(.)
+                  beginBinaryExpression(+)
+                    handleLiteralInt(3)
+                  endBinaryExpression(+)
+                endBinaryExpression(|)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(get, int, {, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, get, h)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(get)
+            handleType(int, null)
+            handleIdentifier(h, methodDeclaration)
+            handleNoTypeVariables({)
+            handleNoFormalParameters({, MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleLiteralInt(1)
+                beginBinaryExpression(+)
+                  handleIdentifier(runtimeType, expression)
+                  handleNoTypeArguments(.)
+                  handleNoArguments(.)
+                  handleSend(runtimeType, .)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(|)
+                  handleNoArguments(|)
+                  handleSend(hashCode, |)
+                  handleEndingBinaryExpression(.)
+                endBinaryExpression(+)
+                beginBinaryExpression(|)
+                  handleLiteralNull(null)
+                  handleIdentifier(hashCode, expressionContinuation)
+                  handleNoTypeArguments(+)
+                  handleNoArguments(+)
+                  handleSend(hashCode, +)
+                  handleEndingBinaryExpression(.)
+                  beginBinaryExpression(+)
+                    handleLiteralInt(3)
+                  endBinaryExpression(+)
+                endBinaryExpression(|)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(get, int, {, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, i)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(i)
+            handleType(int, null)
+            handleIdentifier(i, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleIdentifier(x, expression)
+            handleNoTypeArguments(or)
+            handleNoArguments(or)
+            handleSend(x, or)
+            handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+            beginBinaryExpression(|)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(y, ;)
+            endBinaryExpression(|)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(null, int, (, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, j)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(j)
+            handleType(int, null)
+            handleIdentifier(j, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleIdentifier(x, expression)
+            handleNoTypeArguments(|)
+            handleNoArguments(|)
+            handleSend(x, |)
+            beginBinaryExpression(|)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(y, ;)
+            endBinaryExpression(|)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(null, int, (, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, k)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(k)
+            handleType(int, null)
+            handleIdentifier(k, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(or)
+                handleNoArguments(or)
+                handleSend(x, or)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                beginBinaryExpression(|)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(;)
+                  handleNoArguments(;)
+                  handleSend(y, ;)
+                endBinaryExpression(|)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, l)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(l)
+            handleType(int, null)
+            handleIdentifier(l, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(|)
+                handleNoArguments(|)
+                handleSend(x, |)
+                beginBinaryExpression(|)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(;)
+                  handleNoArguments(;)
+                  handleSend(y, ;)
+                endBinaryExpression(|)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, m)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(m)
+            handleType(int, null)
+            handleIdentifier(m, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              handleIdentifier(int, typeReference)
+              handleNoTypeArguments(z)
+              handleType(int, null)
+              beginVariablesDeclaration(z, null, null)
+                handleIdentifier(z, localVariableDeclaration)
+                beginInitializedIdentifier(z)
+                  beginVariableInitializer(=)
+                    handleIdentifier(x, expression)
+                    handleNoTypeArguments(or)
+                    handleNoArguments(or)
+                    handleSend(x, or)
+                    handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                    beginBinaryExpression(|)
+                      handleIdentifier(y, expression)
+                      handleNoTypeArguments(;)
+                      handleNoArguments(;)
+                      handleSend(y, ;)
+                    endBinaryExpression(|)
+                  endVariableInitializer(=)
+                endInitializedIdentifier(z)
+              endVariablesDeclaration(1, ;)
+              beginReturnStatement(return)
+                handleIdentifier(z, expression)
+                handleNoTypeArguments(;)
+                handleNoArguments(;)
+                handleSend(z, ;)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(2, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, n)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(n)
+            handleType(int, null)
+            handleIdentifier(n, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              handleIdentifier(int, typeReference)
+              handleNoTypeArguments(z)
+              handleType(int, null)
+              beginVariablesDeclaration(z, null, null)
+                handleIdentifier(z, localVariableDeclaration)
+                beginInitializedIdentifier(z)
+                  beginVariableInitializer(=)
+                    handleIdentifier(x, expression)
+                    handleNoTypeArguments(|)
+                    handleNoArguments(|)
+                    handleSend(x, |)
+                    beginBinaryExpression(|)
+                      handleIdentifier(y, expression)
+                      handleNoTypeArguments(;)
+                      handleNoArguments(;)
+                      handleSend(y, ;)
+                    endBinaryExpression(|)
+                  endVariableInitializer(=)
+                endInitializedIdentifier(z)
+              endVariablesDeclaration(1, ;)
+              beginReturnStatement(return)
+                handleIdentifier(z, expression)
+                handleNoTypeArguments(;)
+                handleNoArguments(;)
+                handleSend(z, ;)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(2, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, o)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(o)
+            handleType(int, null)
+            handleIdentifier(o, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleLiteralInt(1)
+            beginBinaryExpression(+)
+              handleIdentifier(x, expression)
+              handleNoTypeArguments(or)
+              handleNoArguments(or)
+              handleSend(x, or)
+            endBinaryExpression(+)
+            handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+            beginBinaryExpression(|)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments(+)
+              handleNoArguments(+)
+              handleSend(y, +)
+              beginBinaryExpression(+)
+                handleLiteralInt(3)
+              endBinaryExpression(+)
+            endBinaryExpression(|)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(null, int, (, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, p)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(p)
+            handleType(int, null)
+            handleIdentifier(p, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleLiteralInt(1)
+            beginBinaryExpression(+)
+              handleIdentifier(x, expression)
+              handleNoTypeArguments(|)
+              handleNoArguments(|)
+              handleSend(x, |)
+            endBinaryExpression(+)
+            beginBinaryExpression(|)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments(+)
+              handleNoArguments(+)
+              handleSend(y, +)
+              beginBinaryExpression(+)
+                handleLiteralInt(3)
+              endBinaryExpression(+)
+            endBinaryExpression(|)
+            handleExpressionFunctionBody(=>, ;)
+          endClassMethod(null, int, (, null, ;)
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, q)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(q)
+            handleType(int, null)
+            handleIdentifier(q, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleLiteralInt(1)
+                beginBinaryExpression(+)
+                  handleIdentifier(x, expression)
+                  handleNoTypeArguments(or)
+                  handleNoArguments(or)
+                  handleSend(x, or)
+                endBinaryExpression(+)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                beginBinaryExpression(|)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(+)
+                  handleNoArguments(+)
+                  handleSend(y, +)
+                  beginBinaryExpression(+)
+                    handleLiteralInt(3)
+                  endBinaryExpression(+)
+                endBinaryExpression(|)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(int)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, r)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(r)
+            handleType(int, null)
+            handleIdentifier(r, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginReturnStatement(return)
+                handleLiteralInt(1)
+                beginBinaryExpression(+)
+                  handleIdentifier(x, expression)
+                  handleNoTypeArguments(|)
+                  handleNoArguments(|)
+                  handleSend(x, |)
+                endBinaryExpression(+)
+                beginBinaryExpression(|)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(+)
+                  handleNoArguments(+)
+                  handleSend(y, +)
+                  beginBinaryExpression(+)
+                    handleLiteralInt(3)
+                  endBinaryExpression(+)
+                endBinaryExpression(|)
+              endReturnStatement(true, return, ;)
+            endBlockFunctionBody(1, {, })
+          endClassMethod(null, int, (, null, })
+        endMember()
+        beginMetadataStar(s)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, s)
+            handleNoType(})
+            handleIdentifier(s, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              handleIdentifier(s, expression)
+              handleNoTypeArguments(()
+              beginArguments(()
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(or)
+                handleNoArguments(or)
+                handleSend(x, or)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                beginBinaryExpression(|)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(,)
+                  handleNoArguments(,)
+                  handleSend(y, ,)
+                endBinaryExpression(|)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(or)
+                handleNoArguments(or)
+                handleSend(x, or)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                beginBinaryExpression(|)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments())
+                  handleNoArguments())
+                  handleSend(y, ))
+                endBinaryExpression(|)
+              endArguments(2, (, ))
+              handleSend(s, ;)
+              handleExpressionStatement(;)
+              handleIdentifier(s, expression)
+              handleNoTypeArguments(()
+              beginArguments(()
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(|)
+                handleNoArguments(|)
+                handleSend(x, |)
+                beginBinaryExpression(|)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(,)
+                  handleNoArguments(,)
+                  handleSend(y, ,)
+                endBinaryExpression(|)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(|)
+                handleNoArguments(|)
+                handleSend(x, |)
+                beginBinaryExpression(|)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments())
+                  handleNoArguments())
+                  handleSend(y, ))
+                endBinaryExpression(|)
+              endArguments(2, (, ))
+              handleSend(s, ;)
+              handleExpressionStatement(;)
+            endBlockFunctionBody(2, {, })
+          endClassMethod(null, s, (, null, })
+        endMember()
+        beginMetadataStar(Key)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, Key)
+            handleNoType(})
+            handleIdentifier(Key, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            beginInitializers(:)
+              beginInitializer(foo)
+                handleIdentifier(foo, expression)
+                handleNoTypeArguments(=)
+                handleNoArguments(=)
+                handleSend(foo, =)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(or)
+                handleNoArguments(or)
+                handleSend(x, or)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                beginBinaryExpression(|)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(,)
+                  handleNoArguments(,)
+                  handleSend(y, ,)
+                endBinaryExpression(|)
+                handleAssignmentExpression(=)
+              endInitializer(,)
+              beginInitializer(bar)
+                handleIdentifier(bar, expression)
+                handleNoTypeArguments(=)
+                handleNoArguments(=)
+                handleSend(bar, =)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(or)
+                handleNoArguments(or)
+                handleSend(x, or)
+                handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                beginBinaryExpression(|)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments({)
+                  handleNoArguments({)
+                  handleSend(y, {)
+                endBinaryExpression(|)
+                handleAssignmentExpression(=)
+              endInitializer({)
+            endInitializers(2, :, {)
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              handleIdentifier(print, expression)
+              handleNoTypeArguments(()
+              beginArguments(()
+                beginLiteralString("hello )
+                  handleIdentifier(x, expression)
+                  handleNoTypeArguments(or)
+                  handleNoArguments(or)
+                  handleSend(x, or)
+                  handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                  beginBinaryExpression(|)
+                    handleIdentifier(y, expression)
+                    handleNoTypeArguments(})
+                    handleNoArguments(})
+                    handleSend(y, })
+                  endBinaryExpression(|)
+                  handleInterpolationExpression(${, })
+                  handleStringPart(")
+                endLiteralString(1, ))
+              endArguments(1, (, ))
+              handleSend(print, ;)
+              handleExpressionStatement(;)
+            endBlockFunctionBody(1, {, })
+          endClassConstructor(null, Key, (, :, })
+        endMember()
+        beginMetadataStar(Key)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, Key)
+            handleNoType(})
+            handleIdentifier(Key, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            beginInitializers(:)
+              beginInitializer(foo)
+                handleIdentifier(foo, expression)
+                handleNoTypeArguments(=)
+                handleNoArguments(=)
+                handleSend(foo, =)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(|)
+                handleNoArguments(|)
+                handleSend(x, |)
+                beginBinaryExpression(|)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments(,)
+                  handleNoArguments(,)
+                  handleSend(y, ,)
+                endBinaryExpression(|)
+                handleAssignmentExpression(=)
+              endInitializer(,)
+              beginInitializer(bar)
+                handleIdentifier(bar, expression)
+                handleNoTypeArguments(=)
+                handleNoArguments(=)
+                handleSend(bar, =)
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(|)
+                handleNoArguments(|)
+                handleSend(x, |)
+                beginBinaryExpression(|)
+                  handleIdentifier(y, expression)
+                  handleNoTypeArguments({)
+                  handleNoArguments({)
+                  handleSend(y, {)
+                endBinaryExpression(|)
+                handleAssignmentExpression(=)
+              endInitializer({)
+            endInitializers(2, :, {)
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              handleIdentifier(print, expression)
+              handleNoTypeArguments(()
+              beginArguments(()
+                beginLiteralString("hello )
+                  handleIdentifier(x, expression)
+                  handleNoTypeArguments(|)
+                  handleNoArguments(|)
+                  handleSend(x, |)
+                  beginBinaryExpression(|)
+                    handleIdentifier(y, expression)
+                    handleNoTypeArguments(})
+                    handleNoArguments(})
+                    handleSend(y, })
+                  endBinaryExpression(|)
+                  handleInterpolationExpression(${, })
+                  handleStringPart(")
+                endLiteralString(1, ))
+              endArguments(1, (, ))
+              handleSend(print, ;)
+              handleExpressionStatement(;)
+            endBlockFunctionBody(1, {, })
+          endClassConstructor(null, Key, (, :, })
+        endMember()
+        beginMetadataStar(not_currently_working)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(null, null, null, null, null, not_currently_working)
+            handleNoType(})
+            handleIdentifier(not_currently_working, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(x)
+                handleType(int, null)
+                handleIdentifier(x, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+              beginMetadataStar(int)
+              endMetadataStar(0)
+              beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(y)
+                handleType(int, null)
+                handleIdentifier(y, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+            endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+              beginMetadataStar(x)
+              endMetadataStar(0)
+              handleIdentifier(x, typeReference)
+              handleNoTypeArguments(or)
+              handleType(x, null)
+              beginVariablesDeclaration(or, null, null)
+                handleIdentifier(or, localVariableDeclaration)
+                beginInitializedIdentifier(or)
+                  handleNoVariableInitializer(or)
+                endInitializedIdentifier(or)
+                handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], or, or)
+              endVariablesDeclaration(1, ;)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(y, ;)
+              handleExpressionStatement(;)
+              handleIdentifier(x, expression)
+              handleNoTypeArguments(|)
+              handleNoArguments(|)
+              handleSend(x, |)
+              beginBinaryExpression(|)
+                handleIdentifier(y, expression)
+                handleNoTypeArguments(;)
+                handleNoArguments(;)
+                handleSend(y, ;)
+              endBinaryExpression(|)
+              handleExpressionStatement(;)
+            endBlockFunctionBody(3, {, })
+          endClassMethod(null, not_currently_working, (, null, })
+        endMember()
+      endClassOrMixinBody(DeclarationKind.Class, 22, {, })
+    endClassDeclaration(abstract, })
+  endTopLevelDeclaration()
+endCompilationUnit(1, )
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.intertwined.expect
new file mode 100644
index 0000000..60507f0
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.intertwined.expect
@@ -0,0 +1,2594 @@
+parseUnit(abstract)
+  skipErrorTokens(abstract)
+  listener: beginCompilationUnit(abstract)
+  syntheticPreviousToken(abstract)
+  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
+    parseMetadataStar()
+      listener: beginMetadataStar(abstract)
+      listener: endMetadataStar(0)
+    parseTopLevelKeywordDeclaration(, class, Instance of 'DirectiveContext')
+      parseClassDeclarationModifiers(, class)
+        parseTopLevelKeywordModifiers(abstract, class)
+      parseClassOrNamedMixinApplication(abstract, class)
+        listener: beginClassOrNamedMixinApplicationPrelude(abstract)
+        ensureIdentifier(class, classOrMixinDeclaration)
+          listener: handleIdentifier(Key, classOrMixinDeclaration)
+        listener: handleNoTypeVariables({)
+        listener: beginClassDeclaration(abstract, abstract, Key)
+        parseClass(Key, abstract, class, Key)
+          parseClassHeaderOpt(Key, abstract, class)
+            parseClassExtendsOpt(Key)
+              listener: handleNoType(Key)
+              listener: handleClassExtends(null, 1)
+            parseWithClauseOpt(Key)
+              listener: handleClassNoWithClause()
+            parseClassOrMixinImplementsOpt(Key)
+              listener: handleClassOrMixinImplements(null, 0)
+            listener: handleClassHeader(abstract, class, null)
+          parseClassOrMixinOrExtensionBody(Key, DeclarationKind.Class, Key)
+            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Key)
+              parseMetadataStar({)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod({, null, null, null, null, null, null, {, Instance of 'SimpleType', get, a, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, a)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(a, methodDeclaration)
+                parseQualifiedRestOpt(a, methodDeclarationContinuation)
+                listener: handleNoTypeVariables(=>)
+                parseGetterOrFormalParameters(a, a, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+                parseInitializersOpt(a)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(a)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(a, false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseSendOrFunctionLiteral(=>, expression)
+                              parseSend(=>, expression)
+                                ensureIdentifier(=>, expression)
+                                  listener: handleIdentifier(runtimeType, expression)
+                                listener: handleNoTypeArguments(.)
+                                parseArgumentsOpt(runtimeType)
+                                  listener: handleNoArguments(.)
+                                listener: handleSend(runtimeType, .)
+                        parsePrimary(., expressionContinuation)
+                          parseSendOrFunctionLiteral(., expressionContinuation)
+                            parseSend(., expressionContinuation)
+                              ensureIdentifier(., expressionContinuation)
+                                listener: handleIdentifier(hashCode, expressionContinuation)
+                              listener: handleNoTypeArguments(or)
+                              parseArgumentsOpt(hashCode)
+                                listener: handleNoArguments(or)
+                              listener: handleSend(hashCode, or)
+                        listener: handleEndingBinaryExpression(.)
+                        rewriter()
+                        parsePrecedenceExpression(|, 10, true)
+                          parseUnaryExpression(|, true)
+                            parsePrimary(|, expression)
+                              parseLiteralNull(|)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                parseArgumentsOpt(hashCode)
+                        reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
+                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                        rewriter()
+                        listener: beginBinaryExpression(|)
+                        parsePrecedenceExpression(|, 10, true)
+                          parseUnaryExpression(|, true)
+                            parsePrimary(|, expression)
+                              parseLiteralNull(|)
+                                listener: handleLiteralNull(null)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(;)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(;)
+                                listener: handleSend(hashCode, ;)
+                          listener: handleEndingBinaryExpression(.)
+                        listener: endBinaryExpression(|)
+                    ensureSemicolon(hashCode)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(get, int, =>, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, b, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, b)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(b, methodDeclaration)
+                parseQualifiedRestOpt(b, methodDeclarationContinuation)
+                listener: handleNoTypeVariables(=>)
+                parseGetterOrFormalParameters(b, b, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+                parseInitializersOpt(b)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(b)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(b, false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseSendOrFunctionLiteral(=>, expression)
+                              parseSend(=>, expression)
+                                ensureIdentifier(=>, expression)
+                                  listener: handleIdentifier(runtimeType, expression)
+                                listener: handleNoTypeArguments(.)
+                                parseArgumentsOpt(runtimeType)
+                                  listener: handleNoArguments(.)
+                                listener: handleSend(runtimeType, .)
+                        parsePrimary(., expressionContinuation)
+                          parseSendOrFunctionLiteral(., expressionContinuation)
+                            parseSend(., expressionContinuation)
+                              ensureIdentifier(., expressionContinuation)
+                                listener: handleIdentifier(hashCode, expressionContinuation)
+                              listener: handleNoTypeArguments(|)
+                              parseArgumentsOpt(hashCode)
+                                listener: handleNoArguments(|)
+                              listener: handleSend(hashCode, |)
+                        listener: handleEndingBinaryExpression(.)
+                        listener: beginBinaryExpression(|)
+                        parsePrecedenceExpression(|, 10, true)
+                          parseUnaryExpression(|, true)
+                            parsePrimary(|, expression)
+                              parseLiteralNull(|)
+                                listener: handleLiteralNull(null)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(;)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(;)
+                                listener: handleSend(hashCode, ;)
+                          listener: handleEndingBinaryExpression(.)
+                        listener: endBinaryExpression(|)
+                    ensureSemicolon(hashCode)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(get, int, =>, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, c, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, c)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(c, methodDeclaration)
+                parseQualifiedRestOpt(c, methodDeclarationContinuation)
+                listener: handleNoTypeVariables({)
+                parseGetterOrFormalParameters(c, c, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
+                parseInitializersOpt(c)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(c)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(c, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(runtimeType, expression)
+                                    listener: handleNoTypeArguments(.)
+                                    parseArgumentsOpt(runtimeType)
+                                      listener: handleNoArguments(.)
+                                    listener: handleSend(runtimeType, .)
+                            parsePrimary(., expressionContinuation)
+                              parseSendOrFunctionLiteral(., expressionContinuation)
+                                parseSend(., expressionContinuation)
+                                  ensureIdentifier(., expressionContinuation)
+                                    listener: handleIdentifier(hashCode, expressionContinuation)
+                                  listener: handleNoTypeArguments(or)
+                                  parseArgumentsOpt(hashCode)
+                                    listener: handleNoArguments(or)
+                                  listener: handleSend(hashCode, or)
+                            listener: handleEndingBinaryExpression(.)
+                            rewriter()
+                            parsePrecedenceExpression(|, 10, true)
+                              parseUnaryExpression(|, true)
+                                parsePrimary(|, expression)
+                                  parseLiteralNull(|)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                    parseArgumentsOpt(hashCode)
+                            reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
+                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                            rewriter()
+                            listener: beginBinaryExpression(|)
+                            parsePrecedenceExpression(|, 10, true)
+                              parseUnaryExpression(|, true)
+                                parsePrimary(|, expression)
+                                  parseLiteralNull(|)
+                                    listener: handleLiteralNull(null)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(;)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(;)
+                                    listener: handleSend(hashCode, ;)
+                              listener: handleEndingBinaryExpression(.)
+                            listener: endBinaryExpression(|)
+                        ensureSemicolon(hashCode)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(get, int, {, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', get, d, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, d)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(d, methodDeclaration)
+                parseQualifiedRestOpt(d, methodDeclarationContinuation)
+                listener: handleNoTypeVariables({)
+                parseGetterOrFormalParameters(d, d, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
+                parseInitializersOpt(d)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(d)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(d, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(runtimeType, expression)
+                                    listener: handleNoTypeArguments(.)
+                                    parseArgumentsOpt(runtimeType)
+                                      listener: handleNoArguments(.)
+                                    listener: handleSend(runtimeType, .)
+                            parsePrimary(., expressionContinuation)
+                              parseSendOrFunctionLiteral(., expressionContinuation)
+                                parseSend(., expressionContinuation)
+                                  ensureIdentifier(., expressionContinuation)
+                                    listener: handleIdentifier(hashCode, expressionContinuation)
+                                  listener: handleNoTypeArguments(|)
+                                  parseArgumentsOpt(hashCode)
+                                    listener: handleNoArguments(|)
+                                  listener: handleSend(hashCode, |)
+                            listener: handleEndingBinaryExpression(.)
+                            listener: beginBinaryExpression(|)
+                            parsePrecedenceExpression(|, 10, true)
+                              parseUnaryExpression(|, true)
+                                parsePrimary(|, expression)
+                                  parseLiteralNull(|)
+                                    listener: handleLiteralNull(null)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(;)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(;)
+                                    listener: handleSend(hashCode, ;)
+                              listener: handleEndingBinaryExpression(.)
+                            listener: endBinaryExpression(|)
+                        ensureSemicolon(hashCode)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(get, int, {, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', get, e, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, e)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(e, methodDeclaration)
+                parseQualifiedRestOpt(e, methodDeclarationContinuation)
+                listener: handleNoTypeVariables(=>)
+                parseGetterOrFormalParameters(e, e, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+                parseInitializersOpt(e)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(e)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(e, false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseLiteralInt(=>)
+                              listener: handleLiteralInt(1)
+                        listener: beginBinaryExpression(+)
+                        parsePrecedenceExpression(+, 14, true)
+                          parseUnaryExpression(+, true)
+                            parsePrimary(+, expression)
+                              parseSendOrFunctionLiteral(+, expression)
+                                parseSend(+, expression)
+                                  ensureIdentifier(+, expression)
+                                    listener: handleIdentifier(runtimeType, expression)
+                                  listener: handleNoTypeArguments(.)
+                                  parseArgumentsOpt(runtimeType)
+                                    listener: handleNoArguments(.)
+                                  listener: handleSend(runtimeType, .)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(or)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(or)
+                                listener: handleSend(hashCode, or)
+                          listener: handleEndingBinaryExpression(.)
+                          rewriter()
+                        listener: endBinaryExpression(+)
+                        rewriter()
+                        parsePrecedenceExpression(|, 10, true)
+                          parseUnaryExpression(|, true)
+                            parsePrimary(|, expression)
+                              parseLiteralNull(|)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                parseArgumentsOpt(hashCode)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                        reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
+                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                        rewriter()
+                        listener: beginBinaryExpression(|)
+                        parsePrecedenceExpression(|, 10, true)
+                          parseUnaryExpression(|, true)
+                            parsePrimary(|, expression)
+                              parseLiteralNull(|)
+                                listener: handleLiteralNull(null)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(+)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(+)
+                                listener: handleSend(hashCode, +)
+                          listener: handleEndingBinaryExpression(.)
+                          listener: beginBinaryExpression(+)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                                  listener: handleLiteralInt(3)
+                          listener: endBinaryExpression(+)
+                        listener: endBinaryExpression(|)
+                    ensureSemicolon(3)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(get, int, =>, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, f, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, f)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(f, methodDeclaration)
+                parseQualifiedRestOpt(f, methodDeclarationContinuation)
+                listener: handleNoTypeVariables(=>)
+                parseGetterOrFormalParameters(f, f, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
+                parseInitializersOpt(f)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(f)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(f, false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseLiteralInt(=>)
+                              listener: handleLiteralInt(1)
+                        listener: beginBinaryExpression(+)
+                        parsePrecedenceExpression(+, 14, true)
+                          parseUnaryExpression(+, true)
+                            parsePrimary(+, expression)
+                              parseSendOrFunctionLiteral(+, expression)
+                                parseSend(+, expression)
+                                  ensureIdentifier(+, expression)
+                                    listener: handleIdentifier(runtimeType, expression)
+                                  listener: handleNoTypeArguments(.)
+                                  parseArgumentsOpt(runtimeType)
+                                    listener: handleNoArguments(.)
+                                  listener: handleSend(runtimeType, .)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(|)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(|)
+                                listener: handleSend(hashCode, |)
+                          listener: handleEndingBinaryExpression(.)
+                        listener: endBinaryExpression(+)
+                        listener: beginBinaryExpression(|)
+                        parsePrecedenceExpression(|, 10, true)
+                          parseUnaryExpression(|, true)
+                            parsePrimary(|, expression)
+                              parseLiteralNull(|)
+                                listener: handleLiteralNull(null)
+                          parsePrimary(., expressionContinuation)
+                            parseSendOrFunctionLiteral(., expressionContinuation)
+                              parseSend(., expressionContinuation)
+                                ensureIdentifier(., expressionContinuation)
+                                  listener: handleIdentifier(hashCode, expressionContinuation)
+                                listener: handleNoTypeArguments(+)
+                                parseArgumentsOpt(hashCode)
+                                  listener: handleNoArguments(+)
+                                listener: handleSend(hashCode, +)
+                          listener: handleEndingBinaryExpression(.)
+                          listener: beginBinaryExpression(+)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                                  listener: handleLiteralInt(3)
+                          listener: endBinaryExpression(+)
+                        listener: endBinaryExpression(|)
+                    ensureSemicolon(3)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(get, int, =>, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, g, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, g)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(g, methodDeclaration)
+                parseQualifiedRestOpt(g, methodDeclarationContinuation)
+                listener: handleNoTypeVariables({)
+                parseGetterOrFormalParameters(g, g, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
+                parseInitializersOpt(g)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(g)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(g, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseLiteralInt(return)
+                                  listener: handleLiteralInt(1)
+                            listener: beginBinaryExpression(+)
+                            parsePrecedenceExpression(+, 14, true)
+                              parseUnaryExpression(+, true)
+                                parsePrimary(+, expression)
+                                  parseSendOrFunctionLiteral(+, expression)
+                                    parseSend(+, expression)
+                                      ensureIdentifier(+, expression)
+                                        listener: handleIdentifier(runtimeType, expression)
+                                      listener: handleNoTypeArguments(.)
+                                      parseArgumentsOpt(runtimeType)
+                                        listener: handleNoArguments(.)
+                                      listener: handleSend(runtimeType, .)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(or)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(or)
+                                    listener: handleSend(hashCode, or)
+                              listener: handleEndingBinaryExpression(.)
+                              rewriter()
+                            listener: endBinaryExpression(+)
+                            rewriter()
+                            parsePrecedenceExpression(|, 10, true)
+                              parseUnaryExpression(|, true)
+                                parsePrimary(|, expression)
+                                  parseLiteralNull(|)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                    parseArgumentsOpt(hashCode)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                            reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
+                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                            rewriter()
+                            listener: beginBinaryExpression(|)
+                            parsePrecedenceExpression(|, 10, true)
+                              parseUnaryExpression(|, true)
+                                parsePrimary(|, expression)
+                                  parseLiteralNull(|)
+                                    listener: handleLiteralNull(null)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(+)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(+)
+                                    listener: handleSend(hashCode, +)
+                              listener: handleEndingBinaryExpression(.)
+                              listener: beginBinaryExpression(+)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                                      listener: handleLiteralInt(3)
+                              listener: endBinaryExpression(+)
+                            listener: endBinaryExpression(|)
+                        ensureSemicolon(3)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(get, int, {, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', get, h, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, get, h)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(get)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
+                  listener: handleIdentifier(h, methodDeclaration)
+                parseQualifiedRestOpt(h, methodDeclarationContinuation)
+                listener: handleNoTypeVariables({)
+                parseGetterOrFormalParameters(h, h, true, MemberKind.NonStaticMethod)
+                  listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
+                parseInitializersOpt(h)
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt(h)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                inPlainSync()
+                parseFunctionBody(h, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseLiteralInt(return)
+                                  listener: handleLiteralInt(1)
+                            listener: beginBinaryExpression(+)
+                            parsePrecedenceExpression(+, 14, true)
+                              parseUnaryExpression(+, true)
+                                parsePrimary(+, expression)
+                                  parseSendOrFunctionLiteral(+, expression)
+                                    parseSend(+, expression)
+                                      ensureIdentifier(+, expression)
+                                        listener: handleIdentifier(runtimeType, expression)
+                                      listener: handleNoTypeArguments(.)
+                                      parseArgumentsOpt(runtimeType)
+                                        listener: handleNoArguments(.)
+                                      listener: handleSend(runtimeType, .)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(|)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(|)
+                                    listener: handleSend(hashCode, |)
+                              listener: handleEndingBinaryExpression(.)
+                            listener: endBinaryExpression(+)
+                            listener: beginBinaryExpression(|)
+                            parsePrecedenceExpression(|, 10, true)
+                              parseUnaryExpression(|, true)
+                                parsePrimary(|, expression)
+                                  parseLiteralNull(|)
+                                    listener: handleLiteralNull(null)
+                              parsePrimary(., expressionContinuation)
+                                parseSendOrFunctionLiteral(., expressionContinuation)
+                                  parseSend(., expressionContinuation)
+                                    ensureIdentifier(., expressionContinuation)
+                                      listener: handleIdentifier(hashCode, expressionContinuation)
+                                    listener: handleNoTypeArguments(+)
+                                    parseArgumentsOpt(hashCode)
+                                      listener: handleNoArguments(+)
+                                    listener: handleSend(hashCode, +)
+                              listener: handleEndingBinaryExpression(.)
+                              listener: beginBinaryExpression(+)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                                      listener: handleLiteralInt(3)
+                              listener: endBinaryExpression(+)
+                            listener: endBinaryExpression(|)
+                        ensureSemicolon(3)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(get, int, {, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, i, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, i)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(i)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(i, methodDeclaration)
+                parseQualifiedRestOpt(i, methodDeclarationContinuation)
+                parseMethodTypeVar(i)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(i, i, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(i, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseSendOrFunctionLiteral(=>, expression)
+                              parseSend(=>, expression)
+                                ensureIdentifier(=>, expression)
+                                  listener: handleIdentifier(x, expression)
+                                listener: handleNoTypeArguments(or)
+                                parseArgumentsOpt(x)
+                                  listener: handleNoArguments(or)
+                                listener: handleSend(x, or)
+                        rewriter()
+                        parsePrecedenceExpression(|, 10, true)
+                          parseUnaryExpression(|, true)
+                            parsePrimary(|, expression)
+                              parseSendOrFunctionLiteral(|, expression)
+                                parseSend(|, expression)
+                                  ensureIdentifier(|, expression)
+                                  parseArgumentsOpt(y)
+                        reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
+                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                        rewriter()
+                        listener: beginBinaryExpression(|)
+                        parsePrecedenceExpression(|, 10, true)
+                          parseUnaryExpression(|, true)
+                            parsePrimary(|, expression)
+                              parseSendOrFunctionLiteral(|, expression)
+                                parseSend(|, expression)
+                                  ensureIdentifier(|, expression)
+                                    listener: handleIdentifier(y, expression)
+                                  listener: handleNoTypeArguments(;)
+                                  parseArgumentsOpt(y)
+                                    listener: handleNoArguments(;)
+                                  listener: handleSend(y, ;)
+                        listener: endBinaryExpression(|)
+                    ensureSemicolon(y)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(null, int, (, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, j, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, j)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(j)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(j, methodDeclaration)
+                parseQualifiedRestOpt(j, methodDeclarationContinuation)
+                parseMethodTypeVar(j)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(j, j, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(j, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseSendOrFunctionLiteral(=>, expression)
+                              parseSend(=>, expression)
+                                ensureIdentifier(=>, expression)
+                                  listener: handleIdentifier(x, expression)
+                                listener: handleNoTypeArguments(|)
+                                parseArgumentsOpt(x)
+                                  listener: handleNoArguments(|)
+                                listener: handleSend(x, |)
+                        listener: beginBinaryExpression(|)
+                        parsePrecedenceExpression(|, 10, true)
+                          parseUnaryExpression(|, true)
+                            parsePrimary(|, expression)
+                              parseSendOrFunctionLiteral(|, expression)
+                                parseSend(|, expression)
+                                  ensureIdentifier(|, expression)
+                                    listener: handleIdentifier(y, expression)
+                                  listener: handleNoTypeArguments(;)
+                                  parseArgumentsOpt(y)
+                                    listener: handleNoArguments(;)
+                                  listener: handleSend(y, ;)
+                        listener: endBinaryExpression(|)
+                    ensureSemicolon(y)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(null, int, (, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, k, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, k)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(k)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(k, methodDeclaration)
+                parseQualifiedRestOpt(k, methodDeclarationContinuation)
+                parseMethodTypeVar(k)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(k, k, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(k, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(x, expression)
+                                    listener: handleNoTypeArguments(or)
+                                    parseArgumentsOpt(x)
+                                      listener: handleNoArguments(or)
+                                    listener: handleSend(x, or)
+                            rewriter()
+                            parsePrecedenceExpression(|, 10, true)
+                              parseUnaryExpression(|, true)
+                                parsePrimary(|, expression)
+                                  parseSendOrFunctionLiteral(|, expression)
+                                    parseSend(|, expression)
+                                      ensureIdentifier(|, expression)
+                                      parseArgumentsOpt(y)
+                            reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
+                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                            rewriter()
+                            listener: beginBinaryExpression(|)
+                            parsePrecedenceExpression(|, 10, true)
+                              parseUnaryExpression(|, true)
+                                parsePrimary(|, expression)
+                                  parseSendOrFunctionLiteral(|, expression)
+                                    parseSend(|, expression)
+                                      ensureIdentifier(|, expression)
+                                        listener: handleIdentifier(y, expression)
+                                      listener: handleNoTypeArguments(;)
+                                      parseArgumentsOpt(y)
+                                        listener: handleNoArguments(;)
+                                      listener: handleSend(y, ;)
+                            listener: endBinaryExpression(|)
+                        ensureSemicolon(y)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, l, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, l)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(l)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(l, methodDeclaration)
+                parseQualifiedRestOpt(l, methodDeclarationContinuation)
+                parseMethodTypeVar(l)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(l, l, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(l, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(x, expression)
+                                    listener: handleNoTypeArguments(|)
+                                    parseArgumentsOpt(x)
+                                      listener: handleNoArguments(|)
+                                    listener: handleSend(x, |)
+                            listener: beginBinaryExpression(|)
+                            parsePrecedenceExpression(|, 10, true)
+                              parseUnaryExpression(|, true)
+                                parsePrimary(|, expression)
+                                  parseSendOrFunctionLiteral(|, expression)
+                                    parseSend(|, expression)
+                                      ensureIdentifier(|, expression)
+                                        listener: handleIdentifier(y, expression)
+                                      listener: handleNoTypeArguments(;)
+                                      parseArgumentsOpt(y)
+                                        listener: handleNoArguments(;)
+                                      listener: handleSend(y, ;)
+                            listener: endBinaryExpression(|)
+                        ensureSemicolon(y)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, m, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, m)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(m)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(m, methodDeclaration)
+                parseQualifiedRestOpt(m, methodDeclarationContinuation)
+                parseMethodTypeVar(m)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(m, m, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(m, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, int)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(z)
+                        listener: beginMetadataStar(int)
+                        listener: endMetadataStar(0)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(z)
+                        listener: handleType(int, null)
+                        listener: beginVariablesDeclaration(z, null, null)
+                        parseVariablesDeclarationRest(int, true)
+                          parseOptionallyInitializedIdentifier(int)
+                            ensureIdentifier(int, localVariableDeclaration)
+                              listener: handleIdentifier(z, localVariableDeclaration)
+                            listener: beginInitializedIdentifier(z)
+                            parseVariableInitializerOpt(z)
+                              listener: beginVariableInitializer(=)
+                              parseExpression(=)
+                                parsePrecedenceExpression(=, 1, true)
+                                  parseUnaryExpression(=, true)
+                                    parsePrimary(=, expression)
+                                      parseSendOrFunctionLiteral(=, expression)
+                                        parseSend(=, expression)
+                                          ensureIdentifier(=, expression)
+                                            listener: handleIdentifier(x, expression)
+                                          listener: handleNoTypeArguments(or)
+                                          parseArgumentsOpt(x)
+                                            listener: handleNoArguments(or)
+                                          listener: handleSend(x, or)
+                                  rewriter()
+                                  parsePrecedenceExpression(|, 10, true)
+                                    parseUnaryExpression(|, true)
+                                      parsePrimary(|, expression)
+                                        parseSendOrFunctionLiteral(|, expression)
+                                          parseSend(|, expression)
+                                            ensureIdentifier(|, expression)
+                                            parseArgumentsOpt(y)
+                                  reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
+                                    listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                                  rewriter()
+                                  listener: beginBinaryExpression(|)
+                                  parsePrecedenceExpression(|, 10, true)
+                                    parseUnaryExpression(|, true)
+                                      parsePrimary(|, expression)
+                                        parseSendOrFunctionLiteral(|, expression)
+                                          parseSend(|, expression)
+                                            ensureIdentifier(|, expression)
+                                              listener: handleIdentifier(y, expression)
+                                            listener: handleNoTypeArguments(;)
+                                            parseArgumentsOpt(y)
+                                              listener: handleNoArguments(;)
+                                            listener: handleSend(y, ;)
+                                  listener: endBinaryExpression(|)
+                              listener: endVariableInitializer(=)
+                            listener: endInitializedIdentifier(z)
+                          ensureSemicolon(y)
+                          listener: endVariablesDeclaration(1, ;)
+                  notEofOrValue(}, return)
+                  parseStatement(;)
+                    parseStatementX(;)
+                      parseReturnStatement(;)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(z, expression)
+                                    listener: handleNoTypeArguments(;)
+                                    parseArgumentsOpt(z)
+                                      listener: handleNoArguments(;)
+                                    listener: handleSend(z, ;)
+                        ensureSemicolon(z)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(2, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, n, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, n)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(n)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(n, methodDeclaration)
+                parseQualifiedRestOpt(n, methodDeclarationContinuation)
+                parseMethodTypeVar(n)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(n, n, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(n, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, int)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(z)
+                        listener: beginMetadataStar(int)
+                        listener: endMetadataStar(0)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(z)
+                        listener: handleType(int, null)
+                        listener: beginVariablesDeclaration(z, null, null)
+                        parseVariablesDeclarationRest(int, true)
+                          parseOptionallyInitializedIdentifier(int)
+                            ensureIdentifier(int, localVariableDeclaration)
+                              listener: handleIdentifier(z, localVariableDeclaration)
+                            listener: beginInitializedIdentifier(z)
+                            parseVariableInitializerOpt(z)
+                              listener: beginVariableInitializer(=)
+                              parseExpression(=)
+                                parsePrecedenceExpression(=, 1, true)
+                                  parseUnaryExpression(=, true)
+                                    parsePrimary(=, expression)
+                                      parseSendOrFunctionLiteral(=, expression)
+                                        parseSend(=, expression)
+                                          ensureIdentifier(=, expression)
+                                            listener: handleIdentifier(x, expression)
+                                          listener: handleNoTypeArguments(|)
+                                          parseArgumentsOpt(x)
+                                            listener: handleNoArguments(|)
+                                          listener: handleSend(x, |)
+                                  listener: beginBinaryExpression(|)
+                                  parsePrecedenceExpression(|, 10, true)
+                                    parseUnaryExpression(|, true)
+                                      parsePrimary(|, expression)
+                                        parseSendOrFunctionLiteral(|, expression)
+                                          parseSend(|, expression)
+                                            ensureIdentifier(|, expression)
+                                              listener: handleIdentifier(y, expression)
+                                            listener: handleNoTypeArguments(;)
+                                            parseArgumentsOpt(y)
+                                              listener: handleNoArguments(;)
+                                            listener: handleSend(y, ;)
+                                  listener: endBinaryExpression(|)
+                              listener: endVariableInitializer(=)
+                            listener: endInitializedIdentifier(z)
+                          ensureSemicolon(y)
+                          listener: endVariablesDeclaration(1, ;)
+                  notEofOrValue(}, return)
+                  parseStatement(;)
+                    parseStatementX(;)
+                      parseReturnStatement(;)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseSendOrFunctionLiteral(return, expression)
+                                  parseSend(return, expression)
+                                    ensureIdentifier(return, expression)
+                                      listener: handleIdentifier(z, expression)
+                                    listener: handleNoTypeArguments(;)
+                                    parseArgumentsOpt(z)
+                                      listener: handleNoArguments(;)
+                                    listener: handleSend(z, ;)
+                        ensureSemicolon(z)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(2, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, o, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, o)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(o)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(o, methodDeclaration)
+                parseQualifiedRestOpt(o, methodDeclarationContinuation)
+                parseMethodTypeVar(o)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(o, o, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(o, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseLiteralInt(=>)
+                              listener: handleLiteralInt(1)
+                        listener: beginBinaryExpression(+)
+                        parsePrecedenceExpression(+, 14, true)
+                          parseUnaryExpression(+, true)
+                            parsePrimary(+, expression)
+                              parseSendOrFunctionLiteral(+, expression)
+                                parseSend(+, expression)
+                                  ensureIdentifier(+, expression)
+                                    listener: handleIdentifier(x, expression)
+                                  listener: handleNoTypeArguments(or)
+                                  parseArgumentsOpt(x)
+                                    listener: handleNoArguments(or)
+                                  listener: handleSend(x, or)
+                          rewriter()
+                        listener: endBinaryExpression(+)
+                        rewriter()
+                        parsePrecedenceExpression(|, 10, true)
+                          parseUnaryExpression(|, true)
+                            parsePrimary(|, expression)
+                              parseSendOrFunctionLiteral(|, expression)
+                                parseSend(|, expression)
+                                  ensureIdentifier(|, expression)
+                                  parseArgumentsOpt(y)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                        reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
+                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                        rewriter()
+                        listener: beginBinaryExpression(|)
+                        parsePrecedenceExpression(|, 10, true)
+                          parseUnaryExpression(|, true)
+                            parsePrimary(|, expression)
+                              parseSendOrFunctionLiteral(|, expression)
+                                parseSend(|, expression)
+                                  ensureIdentifier(|, expression)
+                                    listener: handleIdentifier(y, expression)
+                                  listener: handleNoTypeArguments(+)
+                                  parseArgumentsOpt(y)
+                                    listener: handleNoArguments(+)
+                                  listener: handleSend(y, +)
+                          listener: beginBinaryExpression(+)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                                  listener: handleLiteralInt(3)
+                          listener: endBinaryExpression(+)
+                        listener: endBinaryExpression(|)
+                    ensureSemicolon(3)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(null, int, (, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, p, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, p)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(p)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(p, methodDeclaration)
+                parseQualifiedRestOpt(p, methodDeclarationContinuation)
+                parseMethodTypeVar(p)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(p, p, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(p, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  parseExpressionFunctionBody(=>, false)
+                    parseExpression(=>)
+                      parsePrecedenceExpression(=>, 1, true)
+                        parseUnaryExpression(=>, true)
+                          parsePrimary(=>, expression)
+                            parseLiteralInt(=>)
+                              listener: handleLiteralInt(1)
+                        listener: beginBinaryExpression(+)
+                        parsePrecedenceExpression(+, 14, true)
+                          parseUnaryExpression(+, true)
+                            parsePrimary(+, expression)
+                              parseSendOrFunctionLiteral(+, expression)
+                                parseSend(+, expression)
+                                  ensureIdentifier(+, expression)
+                                    listener: handleIdentifier(x, expression)
+                                  listener: handleNoTypeArguments(|)
+                                  parseArgumentsOpt(x)
+                                    listener: handleNoArguments(|)
+                                  listener: handleSend(x, |)
+                        listener: endBinaryExpression(+)
+                        listener: beginBinaryExpression(|)
+                        parsePrecedenceExpression(|, 10, true)
+                          parseUnaryExpression(|, true)
+                            parsePrimary(|, expression)
+                              parseSendOrFunctionLiteral(|, expression)
+                                parseSend(|, expression)
+                                  ensureIdentifier(|, expression)
+                                    listener: handleIdentifier(y, expression)
+                                  listener: handleNoTypeArguments(+)
+                                  parseArgumentsOpt(y)
+                                    listener: handleNoArguments(+)
+                                  listener: handleSend(y, +)
+                          listener: beginBinaryExpression(+)
+                          parsePrecedenceExpression(+, 14, true)
+                            parseUnaryExpression(+, true)
+                              parsePrimary(+, expression)
+                                parseLiteralInt(+)
+                                  listener: handleLiteralInt(3)
+                          listener: endBinaryExpression(+)
+                        listener: endBinaryExpression(|)
+                    ensureSemicolon(3)
+                    listener: handleExpressionFunctionBody(=>, ;)
+                    inGenerator()
+                listener: endClassMethod(null, int, (, null, ;)
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, q, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, q)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(q)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(q, methodDeclaration)
+                parseQualifiedRestOpt(q, methodDeclarationContinuation)
+                parseMethodTypeVar(q)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(q, q, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(q, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseLiteralInt(return)
+                                  listener: handleLiteralInt(1)
+                            listener: beginBinaryExpression(+)
+                            parsePrecedenceExpression(+, 14, true)
+                              parseUnaryExpression(+, true)
+                                parsePrimary(+, expression)
+                                  parseSendOrFunctionLiteral(+, expression)
+                                    parseSend(+, expression)
+                                      ensureIdentifier(+, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(or)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(or)
+                                      listener: handleSend(x, or)
+                              rewriter()
+                            listener: endBinaryExpression(+)
+                            rewriter()
+                            parsePrecedenceExpression(|, 10, true)
+                              parseUnaryExpression(|, true)
+                                parsePrimary(|, expression)
+                                  parseSendOrFunctionLiteral(|, expression)
+                                    parseSend(|, expression)
+                                      ensureIdentifier(|, expression)
+                                      parseArgumentsOpt(y)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                            reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
+                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                            rewriter()
+                            listener: beginBinaryExpression(|)
+                            parsePrecedenceExpression(|, 10, true)
+                              parseUnaryExpression(|, true)
+                                parsePrimary(|, expression)
+                                  parseSendOrFunctionLiteral(|, expression)
+                                    parseSend(|, expression)
+                                      ensureIdentifier(|, expression)
+                                        listener: handleIdentifier(y, expression)
+                                      listener: handleNoTypeArguments(+)
+                                      parseArgumentsOpt(y)
+                                        listener: handleNoArguments(+)
+                                      listener: handleSend(y, +)
+                              listener: beginBinaryExpression(+)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                                      listener: handleLiteralInt(3)
+                              listener: endBinaryExpression(+)
+                            listener: endBinaryExpression(|)
+                        ensureSemicolon(3)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, int)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(int)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, r, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, r)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(r)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
+                  listener: handleIdentifier(r, methodDeclaration)
+                parseQualifiedRestOpt(r, methodDeclarationContinuation)
+                parseMethodTypeVar(r)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(r, r, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(r, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, return)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseReturnStatement({)
+                        listener: beginReturnStatement(return)
+                        parseExpression(return)
+                          parsePrecedenceExpression(return, 1, true)
+                            parseUnaryExpression(return, true)
+                              parsePrimary(return, expression)
+                                parseLiteralInt(return)
+                                  listener: handleLiteralInt(1)
+                            listener: beginBinaryExpression(+)
+                            parsePrecedenceExpression(+, 14, true)
+                              parseUnaryExpression(+, true)
+                                parsePrimary(+, expression)
+                                  parseSendOrFunctionLiteral(+, expression)
+                                    parseSend(+, expression)
+                                      ensureIdentifier(+, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(|)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(|)
+                                      listener: handleSend(x, |)
+                            listener: endBinaryExpression(+)
+                            listener: beginBinaryExpression(|)
+                            parsePrecedenceExpression(|, 10, true)
+                              parseUnaryExpression(|, true)
+                                parsePrimary(|, expression)
+                                  parseSendOrFunctionLiteral(|, expression)
+                                    parseSend(|, expression)
+                                      ensureIdentifier(|, expression)
+                                        listener: handleIdentifier(y, expression)
+                                      listener: handleNoTypeArguments(+)
+                                      parseArgumentsOpt(y)
+                                        listener: handleNoArguments(+)
+                                      listener: handleSend(y, +)
+                              listener: beginBinaryExpression(+)
+                              parsePrecedenceExpression(+, 14, true)
+                                parseUnaryExpression(+, true)
+                                  parsePrimary(+, expression)
+                                    parseLiteralInt(+)
+                                      listener: handleLiteralInt(3)
+                              listener: endBinaryExpression(+)
+                            listener: endBinaryExpression(|)
+                        ensureSemicolon(3)
+                        listener: endReturnStatement(true, return, ;)
+                        inGenerator()
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassMethod(null, int, (, null, })
+              listener: endMember()
+            notEofOrValue(}, s)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(s)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              isReservedKeyword(()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, s, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, s)
+                listener: handleNoType(})
+                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
+                  listener: handleIdentifier(s, methodDeclaration)
+                parseQualifiedRestOpt(s, methodDeclarationContinuation)
+                parseMethodTypeVar(s)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(s, s, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(s, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, s)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(s)
+                        parseExpressionStatement({)
+                          parseExpression({)
+                            parsePrecedenceExpression({, 1, true)
+                              parseUnaryExpression({, true)
+                                parsePrimary({, expression)
+                                  parseSendOrFunctionLiteral({, expression)
+                                    looksLikeFunctionBody(;)
+                                    parseSend({, expression)
+                                      ensureIdentifier({, expression)
+                                        listener: handleIdentifier(s, expression)
+                                      listener: handleNoTypeArguments(()
+                                      parseArgumentsOpt(s)
+                                        parseArguments(s)
+                                          parseArgumentsRest(()
+                                            listener: beginArguments(()
+                                            parseExpression(()
+                                              parsePrecedenceExpression((, 1, true)
+                                                parseUnaryExpression((, true)
+                                                  parsePrimary((, expression)
+                                                    parseSendOrFunctionLiteral((, expression)
+                                                      parseSend((, expression)
+                                                        ensureIdentifier((, expression)
+                                                          listener: handleIdentifier(x, expression)
+                                                        listener: handleNoTypeArguments(or)
+                                                        parseArgumentsOpt(x)
+                                                          listener: handleNoArguments(or)
+                                                        listener: handleSend(x, or)
+                                                rewriter()
+                                                parsePrecedenceExpression(|, 10, true)
+                                                  parseUnaryExpression(|, true)
+                                                    parsePrimary(|, expression)
+                                                      parseSendOrFunctionLiteral(|, expression)
+                                                        parseSend(|, expression)
+                                                          ensureIdentifier(|, expression)
+                                                          parseArgumentsOpt(y)
+                                                reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
+                                                  listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                                                rewriter()
+                                                listener: beginBinaryExpression(|)
+                                                parsePrecedenceExpression(|, 10, true)
+                                                  parseUnaryExpression(|, true)
+                                                    parsePrimary(|, expression)
+                                                      parseSendOrFunctionLiteral(|, expression)
+                                                        parseSend(|, expression)
+                                                          ensureIdentifier(|, expression)
+                                                            listener: handleIdentifier(y, expression)
+                                                          listener: handleNoTypeArguments(,)
+                                                          parseArgumentsOpt(y)
+                                                            listener: handleNoArguments(,)
+                                                          listener: handleSend(y, ,)
+                                                listener: endBinaryExpression(|)
+                                            parseExpression(,)
+                                              parsePrecedenceExpression(,, 1, true)
+                                                parseUnaryExpression(,, true)
+                                                  parsePrimary(,, expression)
+                                                    parseSendOrFunctionLiteral(,, expression)
+                                                      parseSend(,, expression)
+                                                        ensureIdentifier(,, expression)
+                                                          listener: handleIdentifier(x, expression)
+                                                        listener: handleNoTypeArguments(or)
+                                                        parseArgumentsOpt(x)
+                                                          listener: handleNoArguments(or)
+                                                        listener: handleSend(x, or)
+                                                rewriter()
+                                                parsePrecedenceExpression(|, 10, true)
+                                                  parseUnaryExpression(|, true)
+                                                    parsePrimary(|, expression)
+                                                      parseSendOrFunctionLiteral(|, expression)
+                                                        parseSend(|, expression)
+                                                          ensureIdentifier(|, expression)
+                                                          parseArgumentsOpt(y)
+                                                reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
+                                                  listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                                                rewriter()
+                                                listener: beginBinaryExpression(|)
+                                                parsePrecedenceExpression(|, 10, true)
+                                                  parseUnaryExpression(|, true)
+                                                    parsePrimary(|, expression)
+                                                      parseSendOrFunctionLiteral(|, expression)
+                                                        parseSend(|, expression)
+                                                          ensureIdentifier(|, expression)
+                                                            listener: handleIdentifier(y, expression)
+                                                          listener: handleNoTypeArguments())
+                                                          parseArgumentsOpt(y)
+                                                            listener: handleNoArguments())
+                                                          listener: handleSend(y, ))
+                                                listener: endBinaryExpression(|)
+                                            listener: endArguments(2, (, ))
+                                      listener: handleSend(s, ;)
+                          ensureSemicolon())
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, s)
+                  parseStatement(;)
+                    parseStatementX(;)
+                      parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                        looksLikeLocalFunction(s)
+                        parseExpressionStatement(;)
+                          parseExpression(;)
+                            parsePrecedenceExpression(;, 1, true)
+                              parseUnaryExpression(;, true)
+                                parsePrimary(;, expression)
+                                  parseSendOrFunctionLiteral(;, expression)
+                                    looksLikeFunctionBody(;)
+                                    parseSend(;, expression)
+                                      ensureIdentifier(;, expression)
+                                        listener: handleIdentifier(s, expression)
+                                      listener: handleNoTypeArguments(()
+                                      parseArgumentsOpt(s)
+                                        parseArguments(s)
+                                          parseArgumentsRest(()
+                                            listener: beginArguments(()
+                                            parseExpression(()
+                                              parsePrecedenceExpression((, 1, true)
+                                                parseUnaryExpression((, true)
+                                                  parsePrimary((, expression)
+                                                    parseSendOrFunctionLiteral((, expression)
+                                                      parseSend((, expression)
+                                                        ensureIdentifier((, expression)
+                                                          listener: handleIdentifier(x, expression)
+                                                        listener: handleNoTypeArguments(|)
+                                                        parseArgumentsOpt(x)
+                                                          listener: handleNoArguments(|)
+                                                        listener: handleSend(x, |)
+                                                listener: beginBinaryExpression(|)
+                                                parsePrecedenceExpression(|, 10, true)
+                                                  parseUnaryExpression(|, true)
+                                                    parsePrimary(|, expression)
+                                                      parseSendOrFunctionLiteral(|, expression)
+                                                        parseSend(|, expression)
+                                                          ensureIdentifier(|, expression)
+                                                            listener: handleIdentifier(y, expression)
+                                                          listener: handleNoTypeArguments(,)
+                                                          parseArgumentsOpt(y)
+                                                            listener: handleNoArguments(,)
+                                                          listener: handleSend(y, ,)
+                                                listener: endBinaryExpression(|)
+                                            parseExpression(,)
+                                              parsePrecedenceExpression(,, 1, true)
+                                                parseUnaryExpression(,, true)
+                                                  parsePrimary(,, expression)
+                                                    parseSendOrFunctionLiteral(,, expression)
+                                                      parseSend(,, expression)
+                                                        ensureIdentifier(,, expression)
+                                                          listener: handleIdentifier(x, expression)
+                                                        listener: handleNoTypeArguments(|)
+                                                        parseArgumentsOpt(x)
+                                                          listener: handleNoArguments(|)
+                                                        listener: handleSend(x, |)
+                                                listener: beginBinaryExpression(|)
+                                                parsePrecedenceExpression(|, 10, true)
+                                                  parseUnaryExpression(|, true)
+                                                    parsePrimary(|, expression)
+                                                      parseSendOrFunctionLiteral(|, expression)
+                                                        parseSend(|, expression)
+                                                          ensureIdentifier(|, expression)
+                                                            listener: handleIdentifier(y, expression)
+                                                          listener: handleNoTypeArguments())
+                                                          parseArgumentsOpt(y)
+                                                            listener: handleNoArguments())
+                                                          listener: handleSend(y, ))
+                                                listener: endBinaryExpression(|)
+                                            listener: endArguments(2, (, ))
+                                      listener: handleSend(s, ;)
+                          ensureSemicolon())
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(2, {, })
+                listener: endClassMethod(null, s, (, null, })
+              listener: endMember()
+            notEofOrValue(}, Key)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(Key)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              isReservedKeyword(()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, Key, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, Key)
+                listener: handleNoType(})
+                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
+                  listener: handleIdentifier(Key, methodDeclaration)
+                parseQualifiedRestOpt(Key, methodDeclarationContinuation)
+                parseMethodTypeVar(Key)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(Key, Key, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(Key, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  parseInitializers(:)
+                    listener: beginInitializers(:)
+                    parseInitializer(:)
+                      listener: beginInitializer(foo)
+                      parseInitializerExpressionRest(:)
+                        parseExpression(:)
+                          parsePrecedenceExpression(:, 1, true)
+                            parseUnaryExpression(:, true)
+                              parsePrimary(:, expression)
+                                parseSendOrFunctionLiteral(:, expression)
+                                  parseSend(:, expression)
+                                    ensureIdentifier(:, expression)
+                                      listener: handleIdentifier(foo, expression)
+                                    listener: handleNoTypeArguments(=)
+                                    parseArgumentsOpt(foo)
+                                      listener: handleNoArguments(=)
+                                    listener: handleSend(foo, =)
+                            parsePrecedenceExpression(=, 1, true)
+                              parseUnaryExpression(=, true)
+                                parsePrimary(=, expression)
+                                  parseSendOrFunctionLiteral(=, expression)
+                                    parseSend(=, expression)
+                                      ensureIdentifier(=, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(or)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(or)
+                                      listener: handleSend(x, or)
+                              rewriter()
+                              parsePrecedenceExpression(|, 10, true)
+                                parseUnaryExpression(|, true)
+                                  parsePrimary(|, expression)
+                                    parseSendOrFunctionLiteral(|, expression)
+                                      parseSend(|, expression)
+                                        ensureIdentifier(|, expression)
+                                        parseArgumentsOpt(y)
+                              reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
+                                listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                              rewriter()
+                              listener: beginBinaryExpression(|)
+                              parsePrecedenceExpression(|, 10, true)
+                                parseUnaryExpression(|, true)
+                                  parsePrimary(|, expression)
+                                    parseSendOrFunctionLiteral(|, expression)
+                                      parseSend(|, expression)
+                                        ensureIdentifier(|, expression)
+                                          listener: handleIdentifier(y, expression)
+                                        listener: handleNoTypeArguments(,)
+                                        parseArgumentsOpt(y)
+                                          listener: handleNoArguments(,)
+                                        listener: handleSend(y, ,)
+                              listener: endBinaryExpression(|)
+                            listener: handleAssignmentExpression(=)
+                        listener: endInitializer(,)
+                    parseInitializer(,)
+                      listener: beginInitializer(bar)
+                      parseInitializerExpressionRest(,)
+                        parseExpression(,)
+                          parsePrecedenceExpression(,, 1, true)
+                            parseUnaryExpression(,, true)
+                              parsePrimary(,, expression)
+                                parseSendOrFunctionLiteral(,, expression)
+                                  parseSend(,, expression)
+                                    ensureIdentifier(,, expression)
+                                      listener: handleIdentifier(bar, expression)
+                                    listener: handleNoTypeArguments(=)
+                                    parseArgumentsOpt(bar)
+                                      listener: handleNoArguments(=)
+                                    listener: handleSend(bar, =)
+                            parsePrecedenceExpression(=, 1, true)
+                              parseUnaryExpression(=, true)
+                                parsePrimary(=, expression)
+                                  parseSendOrFunctionLiteral(=, expression)
+                                    parseSend(=, expression)
+                                      ensureIdentifier(=, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(or)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(or)
+                                      listener: handleSend(x, or)
+                              rewriter()
+                              parsePrecedenceExpression(|, 10, true)
+                                parseUnaryExpression(|, true)
+                                  parsePrimary(|, expression)
+                                    parseSendOrFunctionLiteral(|, expression)
+                                      parseSend(|, expression)
+                                        ensureIdentifier(|, expression)
+                                        parseArgumentsOpt(y)
+                              reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
+                                listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                              rewriter()
+                              listener: beginBinaryExpression(|)
+                              parsePrecedenceExpression(|, 10, true)
+                                parseUnaryExpression(|, true)
+                                  parsePrimary(|, expression)
+                                    parseSendOrFunctionLiteral(|, expression)
+                                      parseSend(|, expression)
+                                        ensureIdentifier(|, expression)
+                                          listener: handleIdentifier(y, expression)
+                                        listener: handleNoTypeArguments({)
+                                        parseArgumentsOpt(y)
+                                          listener: handleNoArguments({)
+                                        listener: handleSend(y, {)
+                              listener: endBinaryExpression(|)
+                            listener: handleAssignmentExpression(=)
+                        listener: endInitializer({)
+                    listener: endInitializers(2, :, {)
+                parseAsyncModifierOpt(y)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(y, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, print)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(print)
+                        parseExpressionStatement({)
+                          parseExpression({)
+                            parsePrecedenceExpression({, 1, true)
+                              parseUnaryExpression({, true)
+                                parsePrimary({, expression)
+                                  parseSendOrFunctionLiteral({, expression)
+                                    looksLikeFunctionBody(;)
+                                    parseSend({, expression)
+                                      ensureIdentifier({, expression)
+                                        listener: handleIdentifier(print, expression)
+                                      listener: handleNoTypeArguments(()
+                                      parseArgumentsOpt(print)
+                                        parseArguments(print)
+                                          parseArgumentsRest(()
+                                            listener: beginArguments(()
+                                            parseExpression(()
+                                              parsePrecedenceExpression((, 1, true)
+                                                parseUnaryExpression((, true)
+                                                  parsePrimary((, expression)
+                                                    parseLiteralString(()
+                                                      parseSingleLiteralString(()
+                                                        listener: beginLiteralString("hello )
+                                                        parseExpression(${)
+                                                          parsePrecedenceExpression(${, 1, true)
+                                                            parseUnaryExpression(${, true)
+                                                              parsePrimary(${, expression)
+                                                                parseSendOrFunctionLiteral(${, expression)
+                                                                  parseSend(${, expression)
+                                                                    ensureIdentifier(${, expression)
+                                                                      listener: handleIdentifier(x, expression)
+                                                                    listener: handleNoTypeArguments(or)
+                                                                    parseArgumentsOpt(x)
+                                                                      listener: handleNoArguments(or)
+                                                                    listener: handleSend(x, or)
+                                                            rewriter()
+                                                            parsePrecedenceExpression(|, 10, true)
+                                                              parseUnaryExpression(|, true)
+                                                                parsePrimary(|, expression)
+                                                                  parseSendOrFunctionLiteral(|, expression)
+                                                                    parseSend(|, expression)
+                                                                      ensureIdentifier(|, expression)
+                                                                      parseArgumentsOpt(y)
+                                                            reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
+                                                              listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
+                                                            rewriter()
+                                                            listener: beginBinaryExpression(|)
+                                                            parsePrecedenceExpression(|, 10, true)
+                                                              parseUnaryExpression(|, true)
+                                                                parsePrimary(|, expression)
+                                                                  parseSendOrFunctionLiteral(|, expression)
+                                                                    parseSend(|, expression)
+                                                                      ensureIdentifier(|, expression)
+                                                                        listener: handleIdentifier(y, expression)
+                                                                      listener: handleNoTypeArguments(})
+                                                                      parseArgumentsOpt(y)
+                                                                        listener: handleNoArguments(})
+                                                                      listener: handleSend(y, })
+                                                            listener: endBinaryExpression(|)
+                                                        listener: handleInterpolationExpression(${, })
+                                                        parseStringPart(})
+                                                          listener: handleStringPart(")
+                                                        listener: endLiteralString(1, ))
+                                            listener: endArguments(1, (, ))
+                                      listener: handleSend(print, ;)
+                          ensureSemicolon())
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassConstructor(null, Key, (, :, })
+              listener: endMember()
+            notEofOrValue(}, Key)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(Key)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              isReservedKeyword(()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, Key, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, Key)
+                listener: handleNoType(})
+                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
+                  listener: handleIdentifier(Key, methodDeclaration)
+                parseQualifiedRestOpt(Key, methodDeclarationContinuation)
+                parseMethodTypeVar(Key)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(Key, Key, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(Key, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  parseInitializers(:)
+                    listener: beginInitializers(:)
+                    parseInitializer(:)
+                      listener: beginInitializer(foo)
+                      parseInitializerExpressionRest(:)
+                        parseExpression(:)
+                          parsePrecedenceExpression(:, 1, true)
+                            parseUnaryExpression(:, true)
+                              parsePrimary(:, expression)
+                                parseSendOrFunctionLiteral(:, expression)
+                                  parseSend(:, expression)
+                                    ensureIdentifier(:, expression)
+                                      listener: handleIdentifier(foo, expression)
+                                    listener: handleNoTypeArguments(=)
+                                    parseArgumentsOpt(foo)
+                                      listener: handleNoArguments(=)
+                                    listener: handleSend(foo, =)
+                            parsePrecedenceExpression(=, 1, true)
+                              parseUnaryExpression(=, true)
+                                parsePrimary(=, expression)
+                                  parseSendOrFunctionLiteral(=, expression)
+                                    parseSend(=, expression)
+                                      ensureIdentifier(=, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(|)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(|)
+                                      listener: handleSend(x, |)
+                              listener: beginBinaryExpression(|)
+                              parsePrecedenceExpression(|, 10, true)
+                                parseUnaryExpression(|, true)
+                                  parsePrimary(|, expression)
+                                    parseSendOrFunctionLiteral(|, expression)
+                                      parseSend(|, expression)
+                                        ensureIdentifier(|, expression)
+                                          listener: handleIdentifier(y, expression)
+                                        listener: handleNoTypeArguments(,)
+                                        parseArgumentsOpt(y)
+                                          listener: handleNoArguments(,)
+                                        listener: handleSend(y, ,)
+                              listener: endBinaryExpression(|)
+                            listener: handleAssignmentExpression(=)
+                        listener: endInitializer(,)
+                    parseInitializer(,)
+                      listener: beginInitializer(bar)
+                      parseInitializerExpressionRest(,)
+                        parseExpression(,)
+                          parsePrecedenceExpression(,, 1, true)
+                            parseUnaryExpression(,, true)
+                              parsePrimary(,, expression)
+                                parseSendOrFunctionLiteral(,, expression)
+                                  parseSend(,, expression)
+                                    ensureIdentifier(,, expression)
+                                      listener: handleIdentifier(bar, expression)
+                                    listener: handleNoTypeArguments(=)
+                                    parseArgumentsOpt(bar)
+                                      listener: handleNoArguments(=)
+                                    listener: handleSend(bar, =)
+                            parsePrecedenceExpression(=, 1, true)
+                              parseUnaryExpression(=, true)
+                                parsePrimary(=, expression)
+                                  parseSendOrFunctionLiteral(=, expression)
+                                    parseSend(=, expression)
+                                      ensureIdentifier(=, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(|)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(|)
+                                      listener: handleSend(x, |)
+                              listener: beginBinaryExpression(|)
+                              parsePrecedenceExpression(|, 10, true)
+                                parseUnaryExpression(|, true)
+                                  parsePrimary(|, expression)
+                                    parseSendOrFunctionLiteral(|, expression)
+                                      parseSend(|, expression)
+                                        ensureIdentifier(|, expression)
+                                          listener: handleIdentifier(y, expression)
+                                        listener: handleNoTypeArguments({)
+                                        parseArgumentsOpt(y)
+                                          listener: handleNoArguments({)
+                                        listener: handleSend(y, {)
+                              listener: endBinaryExpression(|)
+                            listener: handleAssignmentExpression(=)
+                        listener: endInitializer({)
+                    listener: endInitializers(2, :, {)
+                parseAsyncModifierOpt(y)
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(y, false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, print)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(print)
+                        parseExpressionStatement({)
+                          parseExpression({)
+                            parsePrecedenceExpression({, 1, true)
+                              parseUnaryExpression({, true)
+                                parsePrimary({, expression)
+                                  parseSendOrFunctionLiteral({, expression)
+                                    looksLikeFunctionBody(;)
+                                    parseSend({, expression)
+                                      ensureIdentifier({, expression)
+                                        listener: handleIdentifier(print, expression)
+                                      listener: handleNoTypeArguments(()
+                                      parseArgumentsOpt(print)
+                                        parseArguments(print)
+                                          parseArgumentsRest(()
+                                            listener: beginArguments(()
+                                            parseExpression(()
+                                              parsePrecedenceExpression((, 1, true)
+                                                parseUnaryExpression((, true)
+                                                  parsePrimary((, expression)
+                                                    parseLiteralString(()
+                                                      parseSingleLiteralString(()
+                                                        listener: beginLiteralString("hello )
+                                                        parseExpression(${)
+                                                          parsePrecedenceExpression(${, 1, true)
+                                                            parseUnaryExpression(${, true)
+                                                              parsePrimary(${, expression)
+                                                                parseSendOrFunctionLiteral(${, expression)
+                                                                  parseSend(${, expression)
+                                                                    ensureIdentifier(${, expression)
+                                                                      listener: handleIdentifier(x, expression)
+                                                                    listener: handleNoTypeArguments(|)
+                                                                    parseArgumentsOpt(x)
+                                                                      listener: handleNoArguments(|)
+                                                                    listener: handleSend(x, |)
+                                                            listener: beginBinaryExpression(|)
+                                                            parsePrecedenceExpression(|, 10, true)
+                                                              parseUnaryExpression(|, true)
+                                                                parsePrimary(|, expression)
+                                                                  parseSendOrFunctionLiteral(|, expression)
+                                                                    parseSend(|, expression)
+                                                                      ensureIdentifier(|, expression)
+                                                                        listener: handleIdentifier(y, expression)
+                                                                      listener: handleNoTypeArguments(})
+                                                                      parseArgumentsOpt(y)
+                                                                        listener: handleNoArguments(})
+                                                                      listener: handleSend(y, })
+                                                            listener: endBinaryExpression(|)
+                                                        listener: handleInterpolationExpression(${, })
+                                                        parseStringPart(})
+                                                          listener: handleStringPart(")
+                                                        listener: endLiteralString(1, ))
+                                            listener: endArguments(1, (, ))
+                                      listener: handleSend(print, ;)
+                          ensureSemicolon())
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(1, {, })
+                listener: endClassConstructor(null, Key, (, :, })
+              listener: endMember()
+            notEofOrValue(}, not_currently_working)
+            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+              parseMetadataStar(})
+                listener: beginMetadataStar(not_currently_working)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              isReservedKeyword(()
+              parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, not_currently_working, DeclarationKind.Class, Key, false)
+                listener: beginMethod(null, null, null, null, null, not_currently_working)
+                listener: handleNoType(})
+                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
+                  listener: handleIdentifier(not_currently_working, methodDeclaration)
+                parseQualifiedRestOpt(not_currently_working, methodDeclarationContinuation)
+                parseMethodTypeVar(not_currently_working)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(not_currently_working, not_currently_working, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(not_currently_working, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(x)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(x, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue(,)
+                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                        parseMetadataStar(,)
+                          listener: beginMetadataStar(int)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleIdentifier(int, typeReference)
+                        listener: handleNoTypeArguments(y)
+                        listener: handleType(int, null)
+                        ensureIdentifier(int, formalParameterDeclaration)
+                          listener: handleIdentifier(y, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, x)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                        looksLikeLocalFunction(or)
+                        listener: beginMetadataStar(x)
+                        listener: endMetadataStar(0)
+                        listener: handleIdentifier(x, typeReference)
+                        listener: handleNoTypeArguments(or)
+                        listener: handleType(x, null)
+                        listener: beginVariablesDeclaration(or, null, null)
+                        parseVariablesDeclarationRest(x, true)
+                          parseOptionallyInitializedIdentifier(x)
+                            ensureIdentifier(x, localVariableDeclaration)
+                              listener: handleIdentifier(or, localVariableDeclaration)
+                            listener: beginInitializedIdentifier(or)
+                            parseVariableInitializerOpt(or)
+                              listener: handleNoVariableInitializer(or)
+                            listener: endInitializedIdentifier(or)
+                          ensureSemicolon(or)
+                            reportRecoverableError(or, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
+                              listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], or, or)
+                            rewriter()
+                          listener: endVariablesDeclaration(1, ;)
+                  notEofOrValue(}, y)
+                  parseStatement(;)
+                    parseStatementX(;)
+                      parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                        looksLikeLocalFunction(y)
+                        parseExpressionStatement(;)
+                          parseExpression(;)
+                            parsePrecedenceExpression(;, 1, true)
+                              parseUnaryExpression(;, true)
+                                parsePrimary(;, expression)
+                                  parseSendOrFunctionLiteral(;, expression)
+                                    parseSend(;, expression)
+                                      ensureIdentifier(;, expression)
+                                        listener: handleIdentifier(y, expression)
+                                      listener: handleNoTypeArguments(;)
+                                      parseArgumentsOpt(y)
+                                        listener: handleNoArguments(;)
+                                      listener: handleSend(y, ;)
+                          ensureSemicolon(y)
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, x)
+                  parseStatement(;)
+                    parseStatementX(;)
+                      parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                        looksLikeLocalFunction(x)
+                        parseExpressionStatement(;)
+                          parseExpression(;)
+                            parsePrecedenceExpression(;, 1, true)
+                              parseUnaryExpression(;, true)
+                                parsePrimary(;, expression)
+                                  parseSendOrFunctionLiteral(;, expression)
+                                    parseSend(;, expression)
+                                      ensureIdentifier(;, expression)
+                                        listener: handleIdentifier(x, expression)
+                                      listener: handleNoTypeArguments(|)
+                                      parseArgumentsOpt(x)
+                                        listener: handleNoArguments(|)
+                                      listener: handleSend(x, |)
+                              listener: beginBinaryExpression(|)
+                              parsePrecedenceExpression(|, 10, true)
+                                parseUnaryExpression(|, true)
+                                  parsePrimary(|, expression)
+                                    parseSendOrFunctionLiteral(|, expression)
+                                      parseSend(|, expression)
+                                        ensureIdentifier(|, expression)
+                                          listener: handleIdentifier(y, expression)
+                                        listener: handleNoTypeArguments(;)
+                                        parseArgumentsOpt(y)
+                                          listener: handleNoArguments(;)
+                                        listener: handleSend(y, ;)
+                              listener: endBinaryExpression(|)
+                          ensureSemicolon(y)
+                          listener: handleExpressionStatement(;)
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(3, {, })
+                listener: endClassMethod(null, not_currently_working, (, null, })
+              listener: endMember()
+            notEofOrValue(}, })
+            listener: endClassOrMixinBody(DeclarationKind.Class, 22, {, })
+          listener: endClassDeclaration(abstract, })
+  listener: endTopLevelDeclaration()
+  reportAllErrorTokens(abstract)
+  listener: endCompilationUnit(1, )
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.parser.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.parser.expect
new file mode 100644
index 0000000..e4a44c2
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.parser.expect
@@ -0,0 +1,87 @@
+NOTICE: Stream was rewritten by parser!
+
+abstract class Key {
+int get a => runtimeType.hashCode | null.hashCode;
+int get b => runtimeType.hashCode | null.hashCode;
+int get c { return runtimeType.hashCode | null.hashCode; }
+int get d { return runtimeType.hashCode | null.hashCode; }
+
+int get e => 1 + runtimeType.hashCode | null.hashCode + 3;
+int get f => 1 + runtimeType.hashCode | null.hashCode + 3;
+int get g { return 1 + runtimeType.hashCode | null.hashCode + 3; }
+int get h { return 1 + runtimeType.hashCode | null.hashCode + 3; }
+
+int i(int x, int y) => x | y;
+int j(int x, int y) => x | y;
+int k(int x, int y) { return x | y; }
+int l(int x, int y) { return x | y; }
+int m(int x, int y) { int z = x | y; return z; }
+int n(int x, int y) { int z = x | y; return z; }
+
+int o(int x, int y) => 1 + x | y + 3;
+int p(int x, int y) => 1 + x | y + 3;
+int q(int x, int y) { return 1 + x | y + 3; }
+int r(int x, int y) { return 1 + x | y + 3; }
+
+s(int x, int y) {
+s(x | y, x | y);
+s(x | y, x | y);
+}
+
+Key(int x, int y) : foo = x | y, bar = x | y {
+print("hello ${x | y}");
+}
+
+Key(int x, int y) : foo = x | y, bar = x | y {
+print("hello ${x | y}");
+}
+
+not_currently_working(int x, int y) {
+x or ;y;
+x | y;
+}
+}
+
+
+abstract[KeywordToken] class[KeywordToken] Key[StringToken] {[BeginToken]
+int[StringToken] get[KeywordToken] a[StringToken] =>[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] |[ReplacementToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] b[StringToken] =>[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] |[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] c[StringToken] {[BeginToken] return[KeywordToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] |[ReplacementToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] get[KeywordToken] d[StringToken] {[BeginToken] return[KeywordToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] |[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] get[KeywordToken] e[StringToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] |[ReplacementToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] f[StringToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] |[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] g[StringToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] |[ReplacementToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] get[KeywordToken] h[StringToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] |[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] i[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] x[StringToken] |[ReplacementToken] y[StringToken];[SimpleToken]
+int[StringToken] j[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] x[StringToken] |[SimpleToken] y[StringToken];[SimpleToken]
+int[StringToken] k[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] x[StringToken] |[ReplacementToken] y[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] l[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] x[StringToken] |[SimpleToken] y[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] m[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] int[StringToken] z[StringToken] =[SimpleToken] x[StringToken] |[ReplacementToken] y[StringToken];[SimpleToken] return[KeywordToken] z[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] n[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] int[StringToken] z[StringToken] =[SimpleToken] x[StringToken] |[SimpleToken] y[StringToken];[SimpleToken] return[KeywordToken] z[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] o[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] x[StringToken] |[ReplacementToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] p[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] x[StringToken] |[SimpleToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] q[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] x[StringToken] |[ReplacementToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] r[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] x[StringToken] |[SimpleToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+
+s[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken]
+s[StringToken]([BeginToken]x[StringToken] |[ReplacementToken] y[StringToken],[SimpleToken] x[StringToken] |[ReplacementToken] y[StringToken])[SimpleToken];[SimpleToken]
+s[StringToken]([BeginToken]x[StringToken] |[SimpleToken] y[StringToken],[SimpleToken] x[StringToken] |[SimpleToken] y[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+Key[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] :[SimpleToken] foo[StringToken] =[SimpleToken] x[StringToken] |[ReplacementToken] y[StringToken],[SimpleToken] bar[StringToken] =[SimpleToken] x[StringToken] |[ReplacementToken] y[StringToken] {[BeginToken]
+print[StringToken]([BeginToken]"hello [StringToken]${[BeginToken]x[StringToken] |[ReplacementToken] y[StringToken]}[SimpleToken]"[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+Key[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] :[SimpleToken] foo[StringToken] =[SimpleToken] x[StringToken] |[SimpleToken] y[StringToken],[SimpleToken] bar[StringToken] =[SimpleToken] x[StringToken] |[SimpleToken] y[StringToken] {[BeginToken]
+print[StringToken]([BeginToken]"hello [StringToken]${[BeginToken]x[StringToken] |[SimpleToken] y[StringToken]}[SimpleToken]"[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+not_currently_working[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken]
+x[StringToken] or[StringToken] ;[SyntheticToken]y[StringToken];[SimpleToken]
+x[StringToken] |[SimpleToken] y[StringToken];[SimpleToken]
+}[SimpleToken]
+}[SimpleToken]
+[SimpleToken]
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.scanner.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.scanner.expect
new file mode 100644
index 0000000..ac05112
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.scanner.expect
@@ -0,0 +1,85 @@
+abstract class Key {
+int get a => runtimeType.hashCode or null.hashCode;
+int get b => runtimeType.hashCode | null.hashCode;
+int get c { return runtimeType.hashCode or null.hashCode; }
+int get d { return runtimeType.hashCode | null.hashCode; }
+
+int get e => 1 + runtimeType.hashCode or null.hashCode + 3;
+int get f => 1 + runtimeType.hashCode | null.hashCode + 3;
+int get g { return 1 + runtimeType.hashCode or null.hashCode + 3; }
+int get h { return 1 + runtimeType.hashCode | null.hashCode + 3; }
+
+int i(int x, int y) => x or y;
+int j(int x, int y) => x | y;
+int k(int x, int y) { return x or y; }
+int l(int x, int y) { return x | y; }
+int m(int x, int y) { int z = x or y; return z; }
+int n(int x, int y) { int z = x | y; return z; }
+
+int o(int x, int y) => 1 + x or y + 3;
+int p(int x, int y) => 1 + x | y + 3;
+int q(int x, int y) { return 1 + x or y + 3; }
+int r(int x, int y) { return 1 + x | y + 3; }
+
+s(int x, int y) {
+s(x or y, x or y);
+s(x | y, x | y);
+}
+
+Key(int x, int y) : foo = x or y, bar = x or y {
+print("hello ${x or y}");
+}
+
+Key(int x, int y) : foo = x | y, bar = x | y {
+print("hello ${x | y}");
+}
+
+not_currently_working(int x, int y) {
+x or y;
+x | y;
+}
+}
+
+
+abstract[KeywordToken] class[KeywordToken] Key[StringToken] {[BeginToken]
+int[StringToken] get[KeywordToken] a[StringToken] =>[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] or[StringToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] b[StringToken] =>[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] |[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] c[StringToken] {[BeginToken] return[KeywordToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] or[StringToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] get[KeywordToken] d[StringToken] {[BeginToken] return[KeywordToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] |[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] get[KeywordToken] e[StringToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] or[StringToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] f[StringToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] |[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] get[KeywordToken] g[StringToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] or[StringToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] get[KeywordToken] h[StringToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] runtimeType[StringToken].[SimpleToken]hashCode[StringToken] |[SimpleToken] null[KeywordToken].[SimpleToken]hashCode[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] i[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] x[StringToken] or[StringToken] y[StringToken];[SimpleToken]
+int[StringToken] j[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] x[StringToken] |[SimpleToken] y[StringToken];[SimpleToken]
+int[StringToken] k[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] x[StringToken] or[StringToken] y[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] l[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] x[StringToken] |[SimpleToken] y[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] m[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] int[StringToken] z[StringToken] =[SimpleToken] x[StringToken] or[StringToken] y[StringToken];[SimpleToken] return[KeywordToken] z[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] n[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] int[StringToken] z[StringToken] =[SimpleToken] x[StringToken] |[SimpleToken] y[StringToken];[SimpleToken] return[KeywordToken] z[StringToken];[SimpleToken] }[SimpleToken]
+
+int[StringToken] o[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] x[StringToken] or[StringToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] p[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] =>[SimpleToken] 1[StringToken] +[SimpleToken] x[StringToken] |[SimpleToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken]
+int[StringToken] q[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] x[StringToken] or[StringToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+int[StringToken] r[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken] return[KeywordToken] 1[StringToken] +[SimpleToken] x[StringToken] |[SimpleToken] y[StringToken] +[SimpleToken] 3[StringToken];[SimpleToken] }[SimpleToken]
+
+s[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken]
+s[StringToken]([BeginToken]x[StringToken] or[StringToken] y[StringToken],[SimpleToken] x[StringToken] or[StringToken] y[StringToken])[SimpleToken];[SimpleToken]
+s[StringToken]([BeginToken]x[StringToken] |[SimpleToken] y[StringToken],[SimpleToken] x[StringToken] |[SimpleToken] y[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+Key[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] :[SimpleToken] foo[StringToken] =[SimpleToken] x[StringToken] or[StringToken] y[StringToken],[SimpleToken] bar[StringToken] =[SimpleToken] x[StringToken] or[StringToken] y[StringToken] {[BeginToken]
+print[StringToken]([BeginToken]"hello [StringToken]${[BeginToken]x[StringToken] or[StringToken] y[StringToken]}[SimpleToken]"[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+Key[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] :[SimpleToken] foo[StringToken] =[SimpleToken] x[StringToken] |[SimpleToken] y[StringToken],[SimpleToken] bar[StringToken] =[SimpleToken] x[StringToken] |[SimpleToken] y[StringToken] {[BeginToken]
+print[StringToken]([BeginToken]"hello [StringToken]${[BeginToken]x[StringToken] |[SimpleToken] y[StringToken]}[SimpleToken]"[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+
+not_currently_working[StringToken]([BeginToken]int[StringToken] x[StringToken],[SimpleToken] int[StringToken] y[StringToken])[SimpleToken] {[BeginToken]
+x[StringToken] or[StringToken] y[StringToken];[SimpleToken]
+x[StringToken] |[SimpleToken] y[StringToken];[SimpleToken]
+}[SimpleToken]
+}[SimpleToken]
+[SimpleToken]
diff --git a/pkg/front_end/test/fasta/parser/token_stream_rewriter_test.dart b/pkg/front_end/test/fasta/parser/token_stream_rewriter_test.dart
index a3abfd1..c1dae7d 100644
--- a/pkg/front_end/test/fasta/parser/token_stream_rewriter_test.dart
+++ b/pkg/front_end/test/fasta/parser/token_stream_rewriter_test.dart
@@ -5,7 +5,8 @@
 import 'package:_fe_analyzer_shared/src/parser/token_stream_rewriter.dart';
 import 'package:_fe_analyzer_shared/src/scanner/scanner.dart'
     show ScannerResult, scanString;
-import 'package:_fe_analyzer_shared/src/scanner/token.dart' show Token;
+import 'package:_fe_analyzer_shared/src/scanner/token.dart'
+    show ReplacementToken, Token, TokenType;
 import 'package:_fe_analyzer_shared/src/scanner/token_impl.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
@@ -129,6 +130,46 @@
     expect(b.next, same(c));
   }
 
+  void test_replaceNextTokenWithSyntheticToken_1() {
+    var a = _makeToken(0, 'a');
+    var b = _makeToken(5, 'b');
+    b.precedingComments = new CommentToken.fromSubstring(
+        TokenType.SINGLE_LINE_COMMENT, "Test comment", 1, 9, 1,
+        canonicalize: true);
+    var c = _makeToken(10, 'c');
+    _link([a, b, c]);
+
+    var rewriter = new TokenStreamRewriterImpl();
+    ReplacementToken replacement =
+        rewriter.replaceNextTokenWithSyntheticToken(a, TokenType.AMPERSAND);
+    expect(b.offset, same(replacement.offset));
+    expect(b.precedingComments, same(replacement.precedingComments));
+    expect(replacement.replacedToken, same(b));
+
+    expect(a.next, same(replacement));
+    expect(replacement.next, same(c));
+    expect(c.next.isEof, true);
+  }
+
+  void test_replaceNextTokenWithSyntheticToken_2() {
+    var a = _makeToken(0, 'a');
+    var b = _makeToken(5, 'b');
+    b.precedingComments = new CommentToken.fromSubstring(
+        TokenType.SINGLE_LINE_COMMENT, "Test comment", 1, 9, 1,
+        canonicalize: true);
+    _link([a, b]);
+
+    var rewriter = new TokenStreamRewriterImpl();
+    ReplacementToken replacement =
+        rewriter.replaceNextTokenWithSyntheticToken(a, TokenType.AMPERSAND);
+    expect(b.offset, same(replacement.offset));
+    expect(b.precedingComments, same(replacement.precedingComments));
+    expect(replacement.replacedToken, same(b));
+
+    expect(a.next, same(replacement));
+    expect(replacement.next.isEof, true);
+  }
+
   void test_moveSynthetic() {
     ScannerResult scanResult = scanString('Foo(bar; baz=0;');
     expect(scanResult.hasErrors, isTrue);
diff --git a/pkg/front_end/test/parser_suite.dart b/pkg/front_end/test/parser_suite.dart
index 5e65244..632e9ee 100644
--- a/pkg/front_end/test/parser_suite.dart
+++ b/pkg/front_end/test/parser_suite.dart
@@ -406,14 +406,18 @@
 
   void doPrint(String s) {
     super.doPrint(s);
-    if (s.startsWith("beginCompilationUnit(") ||
-        s.startsWith("endCompilationUnit(")) {
-      if (indent != 0) {
-        throw "Incorrect indents: '$s' (indent = $indent).\n\n${sb.toString()}";
-      }
-    } else {
-      if (indent <= 0) {
-        throw "Incorrect indents: '$s' (indent = $indent).\n\n${sb.toString()}";
+    if (!annotateLines) {
+      if (s.startsWith("beginCompilationUnit(") ||
+          s.startsWith("endCompilationUnit(")) {
+        if (indent != 0) {
+          throw "Incorrect indents: '$s' (indent = $indent).\n\n"
+              "${sb.toString()}";
+        }
+      } else {
+        if (indent <= 0) {
+          throw "Incorrect indents: '$s' (indent = $indent).\n\n"
+              "${sb.toString()}";
+        }
       }
     }
   }
diff --git a/pkg/front_end/test/spell_checking_list_code.txt b/pkg/front_end/test/spell_checking_list_code.txt
index a0e7fca..6b94883 100644
--- a/pkg/front_end/test/spell_checking_list_code.txt
+++ b/pkg/front_end/test/spell_checking_list_code.txt
@@ -564,12 +564,15 @@
 jumps
 juxtaposition
 juxtapositions
+jvm
 k
 kallentu
 kernel's
 kernel2kernel
 klass
 kmillikin
+kotlin
+kotlinlang
 kustermann
 kv
 k’s
@@ -884,6 +887,7 @@
 redefine
 redirectee
 redirector
+redo
 reexports
 ref
 reflect
@@ -971,7 +975,9 @@
 shas
 shelf
 shifts
+shl
 showing
+shr
 shrinking
 shru
 si
@@ -1026,6 +1032,7 @@
 stderr
 stdin
 stdio
+stdlib
 stdout
 stmt
 str
@@ -1196,6 +1203,7 @@
 unsortable
 unwrapper
 unwraps
+unwritten
 unzip
 upcast
 update2018
@@ -1215,6 +1223,7 @@
 variances
 variant
 variants
+variation
 vary
 vb
 vector
@@ -1238,6 +1247,7 @@
 wc
 weakened
 weakener
+weed
 weird
 weren't
 werror
diff --git a/pkg/front_end/testcases/general/error_recovery/issue_26810.dart b/pkg/front_end/testcases/general/error_recovery/issue_26810.dart
new file mode 100644
index 0000000..ed07e7e
--- /dev/null
+++ b/pkg/front_end/testcases/general/error_recovery/issue_26810.dart
@@ -0,0 +1,45 @@
+// Copyright (c) 2020, 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.
+
+abstract class Key {
+  int get a => runtimeType.hashCode xor null.hashCode;
+  int get b => runtimeType.hashCode ^ null.hashCode;
+  int get c { return runtimeType.hashCode xor null.hashCode; }
+  int get d { return runtimeType.hashCode ^ null.hashCode; }
+
+  int get e => 1 + runtimeType.hashCode xor null.hashCode + 3;
+  int get f => 1 + runtimeType.hashCode ^ null.hashCode + 3;
+  int get g { return 1 + runtimeType.hashCode xor null.hashCode + 3; }
+  int get h { return 1 + runtimeType.hashCode ^ null.hashCode + 3; }
+
+  int i(int x, int y) => x xor y;
+  int j(int x, int y) => x ^ y;
+  int k(int x, int y) { return x xor y; }
+  int l(int x, int y) { return x ^ y; }
+  int m(int x, int y) { int z =  x xor y; return z; }
+  int n(int x, int y) { int z = x ^ y; return z; }
+
+  int o(int x, int y) => 1 + x xor y + 3;
+  int p(int x, int y) => 1 + x ^ y + 3;
+  int q(int x, int y) { return 1 + x xor y + 3; }
+  int r(int x, int y) { return 1 + x ^ y + 3; }
+
+  s(int x, int y) {
+    s(x xor y, x xor y);
+    s(x ^ y, x ^ y);
+  }
+
+  int foo;
+  int bar;
+
+  Key(int x, int y) : foo = x xor y, bar = x xor y {
+    print("hello ${x xor y}");
+  }
+
+  Key.NotDuplicate(int x, int y) : foo = x ^ y, bar = x ^ y {
+    print("hello ${x ^ y}");
+  }
+}
+
+main() {}
\ No newline at end of file
diff --git a/pkg/front_end/testcases/general/error_recovery/issue_26810.dart.outline.expect b/pkg/front_end/testcases/general/error_recovery/issue_26810.dart.outline.expect
new file mode 100644
index 0000000..3e4746b
--- /dev/null
+++ b/pkg/front_end/testcases/general/error_recovery/issue_26810.dart.outline.expect
@@ -0,0 +1,95 @@
+library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:6:37: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int get a => runtimeType.hashCode xor null.hashCode;
+//                                     ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:11:41: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int get e => 1 + runtimeType.hashCode xor null.hashCode + 3;
+//                                         ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:16:28: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int i(int x, int y) => x xor y;
+//                            ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:23:32: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int o(int x, int y) => 1 + x xor y + 3;
+//                                ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:36:31: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   Key(int x, int y) : foo = x xor y, bar = x xor y {
+//                               ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:36:46: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   Key(int x, int y) : foo = x xor y, bar = x xor y {
+//                                              ^^^
+//
+import self as self;
+import "dart:core" as core;
+
+abstract class Key extends core::Object {
+  field core::int* foo;
+  field core::int* bar;
+  constructor •(core::int* x, core::int* y) → self::Key*
+    ;
+  constructor NotDuplicate(core::int* x, core::int* y) → self::Key*
+    ;
+  get a() → core::int*
+    ;
+  get b() → core::int*
+    ;
+  get c() → core::int*
+    ;
+  get d() → core::int*
+    ;
+  get e() → core::int*
+    ;
+  get f() → core::int*
+    ;
+  get g() → core::int*
+    ;
+  get h() → core::int*
+    ;
+  method i(core::int* x, core::int* y) → core::int*
+    ;
+  method j(core::int* x, core::int* y) → core::int*
+    ;
+  method k(core::int* x, core::int* y) → core::int*
+    ;
+  method l(core::int* x, core::int* y) → core::int*
+    ;
+  method m(core::int* x, core::int* y) → core::int*
+    ;
+  method n(core::int* x, core::int* y) → core::int*
+    ;
+  method o(core::int* x, core::int* y) → core::int*
+    ;
+  method p(core::int* x, core::int* y) → core::int*
+    ;
+  method q(core::int* x, core::int* y) → core::int*
+    ;
+  method r(core::int* x, core::int* y) → core::int*
+    ;
+  method s(core::int* x, core::int* y) → dynamic
+    ;
+  abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
+  abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
+  abstract member-signature method _simpleInstanceOf(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOf
+  abstract member-signature method _simpleInstanceOfTrue(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOfTrue
+  abstract member-signature method _simpleInstanceOfFalse(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOfFalse
+  abstract member-signature operator ==(dynamic other) → core::bool*; -> core::Object::==
+  abstract member-signature get hashCode() → core::int*; -> core::Object::hashCode
+  abstract member-signature method toString() → core::String*; -> core::Object::toString
+  abstract member-signature method noSuchMethod(core::Invocation* invocation) → dynamic; -> core::Object::noSuchMethod
+  abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
+}
+static method main() → dynamic
+  ;
diff --git a/pkg/front_end/testcases/general/error_recovery/issue_26810.dart.strong.expect b/pkg/front_end/testcases/general/error_recovery/issue_26810.dart.strong.expect
new file mode 100644
index 0000000..13cf674
--- /dev/null
+++ b/pkg/front_end/testcases/general/error_recovery/issue_26810.dart.strong.expect
@@ -0,0 +1,152 @@
+library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:6:37: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int get a => runtimeType.hashCode xor null.hashCode;
+//                                     ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:11:41: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int get e => 1 + runtimeType.hashCode xor null.hashCode + 3;
+//                                         ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:16:28: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int i(int x, int y) => x xor y;
+//                            ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:23:32: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int o(int x, int y) => 1 + x xor y + 3;
+//                                ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:36:31: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   Key(int x, int y) : foo = x xor y, bar = x xor y {
+//                               ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:36:46: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   Key(int x, int y) : foo = x xor y, bar = x xor y {
+//                                              ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:8:43: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int get c { return runtimeType.hashCode xor null.hashCode; }
+//                                           ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:13:47: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int get g { return 1 + runtimeType.hashCode xor null.hashCode + 3; }
+//                                               ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:18:34: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int k(int x, int y) { return x xor y; }
+//                                  ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:20:36: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int m(int x, int y) { int z =  x xor y; return z; }
+//                                    ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:25:38: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int q(int x, int y) { return 1 + x xor y + 3; }
+//                                      ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:29:9: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//     s(x xor y, x xor y);
+//         ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:29:18: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//     s(x xor y, x xor y);
+//                  ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:37:22: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//     print("hello ${x xor y}");
+//                      ^^^
+//
+import self as self;
+import "dart:core" as core;
+
+abstract class Key extends core::Object {
+  field core::int* foo;
+  field core::int* bar;
+  constructor •(core::int* x, core::int* y) → self::Key*
+    : self::Key::foo = x.{core::int::^}(y), self::Key::bar = x.{core::int::^}(y), super core::Object::•() {
+    core::print("hello ${x.{core::int::^}(y)}");
+  }
+  constructor NotDuplicate(core::int* x, core::int* y) → self::Key*
+    : self::Key::foo = x.{core::int::^}(y), self::Key::bar = x.{core::int::^}(y), super core::Object::•() {
+    core::print("hello ${x.{core::int::^}(y)}");
+  }
+  get a() → core::int*
+    return this.{self::Key::runtimeType}.{core::Object::hashCode}.{core::int::^}(null.{core::Null::hashCode});
+  get b() → core::int*
+    return this.{self::Key::runtimeType}.{core::Object::hashCode}.{core::int::^}(null.{core::Null::hashCode});
+  get c() → core::int* {
+    return this.{self::Key::runtimeType}.{core::Object::hashCode}.{core::int::^}(null.{core::Null::hashCode});
+  }
+  get d() → core::int* {
+    return this.{self::Key::runtimeType}.{core::Object::hashCode}.{core::int::^}(null.{core::Null::hashCode});
+  }
+  get e() → core::int*
+    return 1.{core::num::+}(this.{self::Key::runtimeType}.{core::Object::hashCode}).{core::int::^}(null.{core::Null::hashCode}.{core::num::+}(3));
+  get f() → core::int*
+    return 1.{core::num::+}(this.{self::Key::runtimeType}.{core::Object::hashCode}).{core::int::^}(null.{core::Null::hashCode}.{core::num::+}(3));
+  get g() → core::int* {
+    return 1.{core::num::+}(this.{self::Key::runtimeType}.{core::Object::hashCode}).{core::int::^}(null.{core::Null::hashCode}.{core::num::+}(3));
+  }
+  get h() → core::int* {
+    return 1.{core::num::+}(this.{self::Key::runtimeType}.{core::Object::hashCode}).{core::int::^}(null.{core::Null::hashCode}.{core::num::+}(3));
+  }
+  method i(core::int* x, core::int* y) → core::int*
+    return x.{core::int::^}(y);
+  method j(core::int* x, core::int* y) → core::int*
+    return x.{core::int::^}(y);
+  method k(core::int* x, core::int* y) → core::int* {
+    return x.{core::int::^}(y);
+  }
+  method l(core::int* x, core::int* y) → core::int* {
+    return x.{core::int::^}(y);
+  }
+  method m(core::int* x, core::int* y) → core::int* {
+    core::int* z = x.{core::int::^}(y);
+    return z;
+  }
+  method n(core::int* x, core::int* y) → core::int* {
+    core::int* z = x.{core::int::^}(y);
+    return z;
+  }
+  method o(core::int* x, core::int* y) → core::int*
+    return 1.{core::num::+}(x).{core::int::^}(y.{core::num::+}(3));
+  method p(core::int* x, core::int* y) → core::int*
+    return 1.{core::num::+}(x).{core::int::^}(y.{core::num::+}(3));
+  method q(core::int* x, core::int* y) → core::int* {
+    return 1.{core::num::+}(x).{core::int::^}(y.{core::num::+}(3));
+  }
+  method r(core::int* x, core::int* y) → core::int* {
+    return 1.{core::num::+}(x).{core::int::^}(y.{core::num::+}(3));
+  }
+  method s(core::int* x, core::int* y) → dynamic {
+    this.{self::Key::s}(x.{core::int::^}(y), x.{core::int::^}(y));
+    this.{self::Key::s}(x.{core::int::^}(y), x.{core::int::^}(y));
+  }
+  abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
+  abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
+  abstract member-signature method _simpleInstanceOf(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOf
+  abstract member-signature method _simpleInstanceOfTrue(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOfTrue
+  abstract member-signature method _simpleInstanceOfFalse(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOfFalse
+  abstract member-signature operator ==(dynamic other) → core::bool*; -> core::Object::==
+  abstract member-signature get hashCode() → core::int*; -> core::Object::hashCode
+  abstract member-signature method toString() → core::String*; -> core::Object::toString
+  abstract member-signature method noSuchMethod(core::Invocation* invocation) → dynamic; -> core::Object::noSuchMethod
+  abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/error_recovery/issue_26810.dart.strong.transformed.expect b/pkg/front_end/testcases/general/error_recovery/issue_26810.dart.strong.transformed.expect
new file mode 100644
index 0000000..13cf674
--- /dev/null
+++ b/pkg/front_end/testcases/general/error_recovery/issue_26810.dart.strong.transformed.expect
@@ -0,0 +1,152 @@
+library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:6:37: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int get a => runtimeType.hashCode xor null.hashCode;
+//                                     ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:11:41: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int get e => 1 + runtimeType.hashCode xor null.hashCode + 3;
+//                                         ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:16:28: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int i(int x, int y) => x xor y;
+//                            ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:23:32: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int o(int x, int y) => 1 + x xor y + 3;
+//                                ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:36:31: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   Key(int x, int y) : foo = x xor y, bar = x xor y {
+//                               ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:36:46: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   Key(int x, int y) : foo = x xor y, bar = x xor y {
+//                                              ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:8:43: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int get c { return runtimeType.hashCode xor null.hashCode; }
+//                                           ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:13:47: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int get g { return 1 + runtimeType.hashCode xor null.hashCode + 3; }
+//                                               ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:18:34: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int k(int x, int y) { return x xor y; }
+//                                  ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:20:36: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int m(int x, int y) { int z =  x xor y; return z; }
+//                                    ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:25:38: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//   int q(int x, int y) { return 1 + x xor y + 3; }
+//                                      ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:29:9: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//     s(x xor y, x xor y);
+//         ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:29:18: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//     s(x xor y, x xor y);
+//                  ^^^
+//
+// pkg/front_end/testcases/general/error_recovery/issue_26810.dart:37:22: Error: Binary operator 'xor' is written as '^' instead of the written out word.
+// Try replacing 'xor' with '^'.
+//     print("hello ${x xor y}");
+//                      ^^^
+//
+import self as self;
+import "dart:core" as core;
+
+abstract class Key extends core::Object {
+  field core::int* foo;
+  field core::int* bar;
+  constructor •(core::int* x, core::int* y) → self::Key*
+    : self::Key::foo = x.{core::int::^}(y), self::Key::bar = x.{core::int::^}(y), super core::Object::•() {
+    core::print("hello ${x.{core::int::^}(y)}");
+  }
+  constructor NotDuplicate(core::int* x, core::int* y) → self::Key*
+    : self::Key::foo = x.{core::int::^}(y), self::Key::bar = x.{core::int::^}(y), super core::Object::•() {
+    core::print("hello ${x.{core::int::^}(y)}");
+  }
+  get a() → core::int*
+    return this.{self::Key::runtimeType}.{core::Object::hashCode}.{core::int::^}(null.{core::Null::hashCode});
+  get b() → core::int*
+    return this.{self::Key::runtimeType}.{core::Object::hashCode}.{core::int::^}(null.{core::Null::hashCode});
+  get c() → core::int* {
+    return this.{self::Key::runtimeType}.{core::Object::hashCode}.{core::int::^}(null.{core::Null::hashCode});
+  }
+  get d() → core::int* {
+    return this.{self::Key::runtimeType}.{core::Object::hashCode}.{core::int::^}(null.{core::Null::hashCode});
+  }
+  get e() → core::int*
+    return 1.{core::num::+}(this.{self::Key::runtimeType}.{core::Object::hashCode}).{core::int::^}(null.{core::Null::hashCode}.{core::num::+}(3));
+  get f() → core::int*
+    return 1.{core::num::+}(this.{self::Key::runtimeType}.{core::Object::hashCode}).{core::int::^}(null.{core::Null::hashCode}.{core::num::+}(3));
+  get g() → core::int* {
+    return 1.{core::num::+}(this.{self::Key::runtimeType}.{core::Object::hashCode}).{core::int::^}(null.{core::Null::hashCode}.{core::num::+}(3));
+  }
+  get h() → core::int* {
+    return 1.{core::num::+}(this.{self::Key::runtimeType}.{core::Object::hashCode}).{core::int::^}(null.{core::Null::hashCode}.{core::num::+}(3));
+  }
+  method i(core::int* x, core::int* y) → core::int*
+    return x.{core::int::^}(y);
+  method j(core::int* x, core::int* y) → core::int*
+    return x.{core::int::^}(y);
+  method k(core::int* x, core::int* y) → core::int* {
+    return x.{core::int::^}(y);
+  }
+  method l(core::int* x, core::int* y) → core::int* {
+    return x.{core::int::^}(y);
+  }
+  method m(core::int* x, core::int* y) → core::int* {
+    core::int* z = x.{core::int::^}(y);
+    return z;
+  }
+  method n(core::int* x, core::int* y) → core::int* {
+    core::int* z = x.{core::int::^}(y);
+    return z;
+  }
+  method o(core::int* x, core::int* y) → core::int*
+    return 1.{core::num::+}(x).{core::int::^}(y.{core::num::+}(3));
+  method p(core::int* x, core::int* y) → core::int*
+    return 1.{core::num::+}(x).{core::int::^}(y.{core::num::+}(3));
+  method q(core::int* x, core::int* y) → core::int* {
+    return 1.{core::num::+}(x).{core::int::^}(y.{core::num::+}(3));
+  }
+  method r(core::int* x, core::int* y) → core::int* {
+    return 1.{core::num::+}(x).{core::int::^}(y.{core::num::+}(3));
+  }
+  method s(core::int* x, core::int* y) → dynamic {
+    this.{self::Key::s}(x.{core::int::^}(y), x.{core::int::^}(y));
+    this.{self::Key::s}(x.{core::int::^}(y), x.{core::int::^}(y));
+  }
+  abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
+  abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
+  abstract member-signature method _simpleInstanceOf(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOf
+  abstract member-signature method _simpleInstanceOfTrue(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOfTrue
+  abstract member-signature method _simpleInstanceOfFalse(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOfFalse
+  abstract member-signature operator ==(dynamic other) → core::bool*; -> core::Object::==
+  abstract member-signature get hashCode() → core::int*; -> core::Object::hashCode
+  abstract member-signature method toString() → core::String*; -> core::Object::toString
+  abstract member-signature method noSuchMethod(core::Invocation* invocation) → dynamic; -> core::Object::noSuchMethod
+  abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/error_recovery/issue_26810.dart.textual_outline.expect b/pkg/front_end/testcases/general/error_recovery/issue_26810.dart.textual_outline.expect
new file mode 100644
index 0000000..7cc788c
--- /dev/null
+++ b/pkg/front_end/testcases/general/error_recovery/issue_26810.dart.textual_outline.expect
@@ -0,0 +1,31 @@
+abstract class Key {
+  int get a => runtimeType.hashCode ^ null.hashCode;
+  int get b => runtimeType.hashCode ^ null.hashCode;
+  int get c {}
+  int get d {}
+  int get e => 1 + runtimeType.hashCode ^ null.hashCode + 3;
+  int get f => 1 + runtimeType.hashCode ^ null.hashCode + 3;
+  int get g {}
+  int get h {}
+  int i(int x, int y) => x ^ y;
+  int j(int x, int y) => x ^ y;
+  int k(int x, int y) {}
+  int l(int x, int y) {}
+  int m(int x, int y) {}
+  int n(int x, int y) {}
+  int o(int x, int y) => 1 + x ^ y + 3;
+  int p(int x, int y) => 1 + x ^ y + 3;
+  int q(int x, int y) {}
+  int r(int x, int y) {}
+  s(int x, int y) {}
+  int foo;
+  int bar;
+  Key(int x, int y)
+      : foo = x ^ y,
+        bar = x ^ y {}
+  Key.NotDuplicate(int x, int y)
+      : foo = x ^ y,
+        bar = x ^ y {}
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/error_recovery/issue_26810.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/error_recovery/issue_26810.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..25de27c7
--- /dev/null
+++ b/pkg/front_end/testcases/general/error_recovery/issue_26810.dart.textual_outline_modelled.expect
@@ -0,0 +1,31 @@
+abstract class Key {
+  Key(int x, int y)
+      : foo = x ^ y,
+        bar = x ^ y {}
+  Key.NotDuplicate(int x, int y)
+      : foo = x ^ y,
+        bar = x ^ y {}
+  int bar;
+  int foo;
+  int get a => runtimeType.hashCode ^ null.hashCode;
+  int get b => runtimeType.hashCode ^ null.hashCode;
+  int get c {}
+  int get d {}
+  int get e => 1 + runtimeType.hashCode ^ null.hashCode + 3;
+  int get f => 1 + runtimeType.hashCode ^ null.hashCode + 3;
+  int get g {}
+  int get h {}
+  int i(int x, int y) => x ^ y;
+  int j(int x, int y) => x ^ y;
+  int k(int x, int y) {}
+  int l(int x, int y) {}
+  int m(int x, int y) {}
+  int n(int x, int y) {}
+  int o(int x, int y) => 1 + x ^ y + 3;
+  int p(int x, int y) => 1 + x ^ y + 3;
+  int q(int x, int y) {}
+  int r(int x, int y) {}
+  s(int x, int y) {}
+}
+
+main() {}
diff --git a/pkg/test_runner/tool/update_static_error_tests.dart b/pkg/test_runner/tool/update_static_error_tests.dart
index de25ab3..eacb060 100644
--- a/pkg/test_runner/tool/update_static_error_tests.dart
+++ b/pkg/test_runner/tool/update_static_error_tests.dart
@@ -19,9 +19,9 @@
 const _usage =
     "Usage: dart update_static_error_tests.dart [flags...] <path glob>";
 
-final _dartPath = _findBinary("dart");
-final _analyzerPath = _findBinary("dartanalyzer");
-final _dart2jsPath = _findBinary("dart2js");
+final _dartPath = _findBinary("dart", "exe");
+final _analyzerPath = _findBinary("dartanalyzer", "bat");
+final _dart2jsPath = _findBinary("dart2js", "bat");
 
 Future<void> main(List<String> args) async {
   var sources = ErrorSource.all.map((e) => e.marker).toList();
@@ -301,8 +301,8 @@
 }
 
 /// Find the most recently-built [binary] in any of the build directories.
-String _findBinary(String binary) {
-  if (Platform.isWindows) binary += ".bat";
+String _findBinary(String name, String windowsExtension) {
+  String binary = Platform.isWindows ? "$name.$windowsExtension" : name;
 
   String newestPath;
   DateTime newestTime;
@@ -310,13 +310,13 @@
   var buildDirectory = Directory(Platform.isMacOS ? "xcodebuild" : "out");
   if (buildDirectory.existsSync()) {
     for (var config in buildDirectory.listSync()) {
-      var analyzerPath = p.join(config.path, "dart-sdk", "bin", binary);
-      var analyzerFile = File(analyzerPath);
-      if (!analyzerFile.existsSync()) continue;
-      var modified = analyzerFile.lastModifiedSync();
+      var path = p.join(config.path, "dart-sdk", "bin", binary);
+      var file = File(path);
+      if (!file.existsSync()) continue;
+      var modified = file.lastModifiedSync();
 
       if (newestTime == null || modified.isAfter(newestTime)) {
-        newestPath = analyzerPath;
+        newestPath = path;
         newestTime = modified;
       }
     }
diff --git a/runtime/vm/compiler/frontend/base_flow_graph_builder.cc b/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
index fdcd957..8f00b30 100644
--- a/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
+++ b/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
@@ -682,10 +682,15 @@
   return instructions;
 }
 
-LocalVariable* BaseFlowGraphBuilder::MakeTemporary() {
-  char name[64];
+LocalVariable* BaseFlowGraphBuilder::MakeTemporary(const char* suffix) {
+  static constexpr intptr_t kTemporaryNameLength = 64;
+  char name[kTemporaryNameLength];
   intptr_t index = stack_->definition()->temp_index();
-  Utils::SNPrint(name, 64, ":t%" Pd, index);
+  if (suffix != nullptr) {
+    Utils::SNPrint(name, kTemporaryNameLength, ":t_%s", suffix);
+  } else {
+    Utils::SNPrint(name, kTemporaryNameLength, ":t%" Pd, index);
+  }
   const String& symbol_name =
       String::ZoneHandle(Z, Symbols::New(thread_, name));
   LocalVariable* variable =
@@ -707,6 +712,16 @@
   return variable;
 }
 
+Fragment BaseFlowGraphBuilder::DropTemporary(LocalVariable** temp) {
+  ASSERT(temp != nullptr && *temp != nullptr && (*temp)->HasIndex());
+  // Check that the temporary matches the current stack definition.
+  ASSERT_EQUAL(
+      stack_->definition()->temp_index(),
+      -(*temp)->index().value() - parsed_function_->num_stack_locals());
+  *temp = nullptr;  // Clear to avoid inadvertent usage after dropping.
+  return Drop();
+}
+
 void BaseFlowGraphBuilder::SetTempIndex(Definition* definition) {
   definition->set_temp_index(
       stack_ == NULL ? 0 : stack_->definition()->temp_index() + 1);
diff --git a/runtime/vm/compiler/frontend/base_flow_graph_builder.h b/runtime/vm/compiler/frontend/base_flow_graph_builder.h
index 6cfd0b8..3160351 100644
--- a/runtime/vm/compiler/frontend/base_flow_graph_builder.h
+++ b/runtime/vm/compiler/frontend/base_flow_graph_builder.h
@@ -183,6 +183,9 @@
   void SetTempIndex(Definition* definition);
 
   Fragment LoadLocal(LocalVariable* variable);
+  Fragment StoreLocal(LocalVariable* variable) {
+    return StoreLocal(TokenPosition::kNoSource, variable);
+  }
   Fragment StoreLocal(TokenPosition position, LocalVariable* variable);
   Fragment StoreLocalRaw(TokenPosition position, LocalVariable* variable);
   Fragment LoadContextAt(int depth);
@@ -242,8 +245,8 @@
   //       goto B3
   //     B3:
   //       LoadLocal(t)
-  //
-  LocalVariable* MakeTemporary();
+  LocalVariable* MakeTemporary(const char* suffix = nullptr);
+  Fragment DropTemporary(LocalVariable** temp);
 
   InputsArray* GetArguments(int count);
 
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.cc b/runtime/vm/compiler/frontend/kernel_to_il.cc
index 396cef9..036de46 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.cc
+++ b/runtime/vm/compiler/frontend/kernel_to_il.cc
@@ -1929,84 +1929,124 @@
                            prologue_info);
 }
 
-Fragment FlowGraphBuilder::BuildDynamicCallVarsInit(LocalVariable* closure) {
-  auto const vars = parsed_function_->dynamic_closure_call_vars();
-  ASSERT(vars != nullptr);
-  ASSERT(has_saved_args_desc_array());
-  const ArgumentsDescriptor descriptor(saved_args_desc_array());
-  auto const rep = Slot::Function_packed_fields().representation();
+// Information used by the various dynamic closure call fragment builders.
+struct FlowGraphBuilder::ClosureCallInfo {
+  ClosureCallInfo(LocalVariable* closure,
+                  JoinEntryInstr* throw_no_such_method,
+                  const Array& arguments_descriptor_array,
+                  ParsedFunction::DynamicClosureCallVars* const vars)
+      : closure(ASSERT_NOTNULL(closure)),
+        throw_no_such_method(ASSERT_NOTNULL(throw_no_such_method)),
+        descriptor(arguments_descriptor_array),
+        vars(ASSERT_NOTNULL(vars)) {}
 
-  // We extract all the packed fields here so code generation that puts unboxed
-  // integers on the expression stack even in unoptimized code is in one place.
+  LocalVariable* const closure;
+  JoinEntryInstr* const throw_no_such_method;
+  const ArgumentsDescriptor descriptor;
+  ParsedFunction::DynamicClosureCallVars* const vars;
 
-  Fragment init;
-  init += LoadLocal(closure);
-  init += LoadNativeField(Slot::Closure_function());
-  init += LoadNativeField(Slot::Function_packed_fields());
-  init +=
-      BuildExtractPackedFieldIntoSmi<Function::PackedNumFixedParameters>(rep);
-  init += StoreLocal(TokenPosition::kNoSource, vars->num_fixed_params);
-  // Not dropping as we'll use the value to get the max number of parameters.
+  // Set up by BuildDynamicCallChecks() when needed. These values are
+  // read-only, so they don't need real local variables and are created
+  // using MakeTemporary().
+  LocalVariable* function = nullptr;
+  LocalVariable* num_fixed_params = nullptr;
+  LocalVariable* num_opt_params = nullptr;
+  LocalVariable* num_max_params = nullptr;
+  LocalVariable* has_named_params = nullptr;
+  LocalVariable* parameter_names = nullptr;
+  LocalVariable* type_parameters = nullptr;
+};
 
-  init += LoadLocal(closure);
-  init += LoadNativeField(Slot::Closure_function());
-  init += LoadNativeField(Slot::Function_packed_fields());
-  init += BuildExtractPackedFieldIntoSmi<Function::PackedNumOptionalParameters>(
-      rep);
-  init += StoreLocal(TokenPosition::kNoSource, vars->num_opt_params);
-  init += SmiBinaryOp(Token::kADD);
-  init += StoreLocal(TokenPosition::kNoSource, vars->num_max_params);
-  init += Drop();
+Fragment FlowGraphBuilder::TestClosureFunctionNamedParameterRequired(
+    const ClosureCallInfo& info,
+    Fragment set,
+    Fragment not_set) {
+  // Required named arguments only exist if null_safety is enabled.
+  if (!I->null_safety()) return not_set;
 
-  // Currently, we only need this initialized to either check provided optional
-  // names, if any, or to check for missing required parameters if null safe.
-  if (Isolate::Current()->null_safety() || descriptor.NamedCount() > 0) {
-    init += LoadLocal(closure);
-    init += LoadNativeField(Slot::Closure_function());
-    init += LoadNativeField(Slot::Function_parameter_names());
-    init += StoreLocal(TokenPosition::kNoSource, vars->parameter_names);
-    init += Drop();
-  }
+  Fragment check_required;
+  // First, we convert the index to be in terms of the number of optional
+  // parameters, not total parameters (to calculate the flag index and shift).
+  check_required += LoadLocal(info.vars->current_param_index);
+  check_required += LoadLocal(info.num_fixed_params);
+  check_required += SmiBinaryOp(Token::kSUB, /*is_truncating=*/true);
+  LocalVariable* opt_index = MakeTemporary("opt_index");  // Read-only.
 
-  init += LoadLocal(closure);
-  init += LoadNativeField(Slot::Closure_function());
-  init += LoadNativeField(Slot::Function_packed_fields());
-  init += BuildExtractPackedFieldIntoSmi<
-      Function::PackedHasNamedOptionalParameters>(rep);
-  init += IntConstant(0);
-  TargetEntryInstr *is_true, *is_false;
-  init += BranchIfEqual(&is_false, &is_true);
+  // Next, we calculate the index to dereference in the parameter names array.
+  check_required += LoadLocal(opt_index);
+  check_required +=
+      IntConstant(compiler::target::kNumParameterFlagsPerElementLog2);
+  check_required += SmiBinaryOp(Token::kSHR);
+  check_required += LoadLocal(info.num_max_params);
+  check_required += SmiBinaryOp(Token::kADD);
+  LocalVariable* flags_index = MakeTemporary("flags_index");  // Read-only.
 
-  JoinEntryInstr* join = BuildJoinEntry();
-  init.current = join;
+  // Two read-only stack values (opt_index, flag_index) that must be dropped
+  // after we rejoin at after_check.
+  JoinEntryInstr* after_check = BuildJoinEntry();
 
-  Fragment true_branch(is_true);
-  true_branch += Constant(Object::bool_true());
-  true_branch += StoreLocal(TokenPosition::kNoSource, vars->has_named_params);
-  true_branch += Drop();
-  true_branch += Goto(join);
+  // Now we check to see if the flags index is within the bounds of the
+  // parameters names array. If not, it cannot be required.
+  check_required += LoadLocal(flags_index);
+  check_required += LoadLocal(info.parameter_names);
+  check_required += LoadNativeField(Slot::Array_length());
+  check_required += SmiRelationalOp(Token::kLT);
+  TargetEntryInstr *valid_index, *invalid_index;
+  check_required += BranchIfTrue(&valid_index, &invalid_index);
 
-  Fragment false_branch(is_false);
-  false_branch += Constant(Object::bool_false());
-  false_branch += StoreLocal(TokenPosition::kNoSource, vars->has_named_params);
-  false_branch += Drop();
-  false_branch += Goto(join);
+  JoinEntryInstr* join_not_set = BuildJoinEntry();
 
-  return init;
+  Fragment(invalid_index) + Goto(join_not_set);
+
+  // Otherwise, we need to retrieve the value. We're guaranteed the Smis in
+  // the flag slots are non-null, so after loading we can immediate check
+  // the required flag bit for the given named parameter.
+  check_required.current = valid_index;
+  check_required += LoadLocal(info.parameter_names);
+  check_required += LoadLocal(flags_index);
+  check_required += LoadIndexed(compiler::target::kWordSize);
+  check_required += LoadLocal(opt_index);
+  check_required +=
+      IntConstant(compiler::target::kNumParameterFlagsPerElement - 1);
+  check_required += SmiBinaryOp(Token::kBIT_AND);
+  // If the below changes, we'll need to multiply by the number of parameter
+  // flags before shifting.
+  static_assert(compiler::target::kNumParameterFlags == 1,
+                "IL builder assumes only one flag bit per parameter");
+  check_required += SmiBinaryOp(Token::kSHR);
+  check_required +=
+      IntConstant(1 << compiler::target::kRequiredNamedParameterFlag);
+  check_required += SmiBinaryOp(Token::kBIT_AND);
+  check_required += IntConstant(0);
+  TargetEntryInstr *is_not_set, *is_set;
+  check_required += BranchIfEqual(&is_not_set, &is_set);
+
+  Fragment(is_not_set) + Goto(join_not_set);
+
+  set.Prepend(is_set);
+  set += Goto(after_check);
+
+  not_set.Prepend(join_not_set);
+  not_set += Goto(after_check);
+
+  // After rejoining, drop the introduced temporaries.
+  check_required.current = after_check;
+  check_required += DropTemporary(&flags_index);
+  check_required += DropTemporary(&opt_index);
+  return check_required;
 }
 
-Fragment FlowGraphBuilder::BuildClosureCallHasRequiredNamedArgumentsCheck(
-    LocalVariable* closure,
-    JoinEntryInstr* nsm) {
-  auto const vars = parsed_function_->dynamic_closure_call_vars();
-  ASSERT(vars != nullptr);
-  ASSERT(has_saved_args_desc_array());
-  const ArgumentsDescriptor descriptor(saved_args_desc_array());
-
-  // Required named arguments only exist if null_safety is enabled.
-  if (!Isolate::Current()->null_safety()) return Fragment();
-
-  if (descriptor.NamedCount() == 0) {
+Fragment FlowGraphBuilder::BuildClosureCallNamedArgumentsCheck(
+    const ClosureCallInfo& info) {
+  // When no named arguments are provided, we just need to check for possible
+  // required named arguments.
+  if (info.descriptor.NamedCount() == 0) {
+    // No work to do if there are no possible required named parameters.
+    if (!I->null_safety()) {
+      return Fragment();
+    }
+    // If the below changes, we can no longer assume that flag slots existing
+    // means there are required parameters.
     static_assert(compiler::target::kNumParameterFlags == 1,
                   "IL builder assumes only one flag bit per parameter");
     // No named args were provided, so check for any required named params.
@@ -2014,193 +2054,177 @@
     // for named parameters. If this changes, we'll need to check each flag
     // entry appropriately for any set required bits.
     Fragment has_any;
-    has_any += LoadLocal(vars->num_max_params);
-    has_any += LoadLocal(vars->parameter_names);
+    has_any += LoadLocal(info.num_max_params);
+    has_any += LoadLocal(info.parameter_names);
     has_any += LoadNativeField(Slot::Array_length());
     TargetEntryInstr *no_required, *has_required;
     has_any += BranchIfEqual(&no_required, &has_required);
 
-    Fragment(has_required) + Goto(nsm);
+    Fragment(has_required) + Goto(info.throw_no_such_method);
 
     return Fragment(has_any.entry, no_required);
   }
 
-  // Loop over the indexes of the named parameters of the function, checking
-  // whether the named parameter at that index is required. If it is, then
-  // check whether it matches any of the names in the ArgumentsDescriptor.
-  JoinEntryInstr* loop = BuildJoinEntry();
+  // Otherwise, we need to loop through the parameter names to check the names
+  // of named arguments for validity (and possibly missing required ones).
+  Fragment check_names;
+  check_names += LoadLocal(info.vars->current_param_index);
+  LocalVariable* old_index = MakeTemporary("old_index");  // Read-only.
+  check_names += LoadLocal(info.vars->current_num_processed);
+  LocalVariable* old_processed = MakeTemporary("old_processed");  // Read-only.
 
-  // We iterate from [0, num_named), not [num_fixed, num_named) because the
-  // flag mask and index is based off the named index, not the param index.
-  Fragment check_required;
-  check_required += IntConstant(0);
-  check_required +=
-      StoreLocal(TokenPosition::kNoSource, vars->current_param_index);
-  check_required += Drop();
-  check_required += Goto(loop);
+  // Two local stack values (old_index, old_processed) to drop after rejoining
+  // at done.
+  JoinEntryInstr* loop = BuildJoinEntry();
+  JoinEntryInstr* done = BuildJoinEntry();
+
+  check_names += IntConstant(0);
+  check_names += StoreLocal(info.vars->current_num_processed);
+  check_names += Drop();
+  check_names += LoadLocal(info.num_fixed_params);
+  check_names += StoreLocal(info.vars->current_param_index);
+  check_names += Drop();
+  check_names += Goto(loop);
 
   Fragment loop_check(loop);
-  loop_check += LoadLocal(vars->current_param_index);
-  loop_check += LoadLocal(vars->num_opt_params);
+  loop_check += LoadLocal(info.vars->current_param_index);
+  loop_check += LoadLocal(info.num_max_params);
   loop_check += SmiRelationalOp(Token::kLT);
   TargetEntryInstr *no_more, *more;
   loop_check += BranchIfTrue(&more, &no_more);
 
-  JoinEntryInstr* done = BuildJoinEntry();
   Fragment(no_more) + Goto(done);
 
   Fragment loop_body(more);
-  // First, we calculate the index to dereference into the parameter names
-  // array and store it in :expr_temp.
-  loop_body += LoadLocal(vars->num_max_params);
-  loop_body += LoadLocal(vars->current_param_index);
-  loop_body += IntConstant(compiler::target::kNumParameterFlagsPerElementLog2);
-  loop_body += SmiBinaryOp(Token::kSHR);
-  loop_body += SmiBinaryOp(Token::kADD);
-  LocalVariable* temp = parsed_function_->expression_temp_var();
-  loop_body += StoreLocal(TokenPosition::kNoSource, temp);
-  // Now we check to see if it is within the bounds of the parameters names
-  // array. If not, we're done, as this and later indices cannot be required.
-  loop_body += LoadLocal(vars->parameter_names);
-  loop_body += LoadNativeField(Slot::Array_length());
-  loop_body += SmiRelationalOp(Token::kLT);
-  TargetEntryInstr *valid_index, *invalid_index;
-  loop_body += BranchIfTrue(&valid_index, &invalid_index);
-
-  Fragment(invalid_index) + Goto(done);
-
-  // Otherwise, we need to retrieve the value and check the appropriate bit.
-  loop_body.current = valid_index;
-  loop_body += LoadLocal(vars->parameter_names);
-  loop_body += LoadLocal(temp);  // Index into parameter names array.
+  // First load the name we need to check against.
+  loop_body += LoadLocal(info.parameter_names);
+  loop_body += LoadLocal(info.vars->current_param_index);
   loop_body += LoadIndexed(compiler::target::kWordSize);
-  loop_body += LoadLocal(vars->current_param_index);
-  loop_body += IntConstant(compiler::target::kNumParameterFlagsPerElement - 1);
-  loop_body += SmiBinaryOp(Token::kBIT_AND);
-  if (compiler::target::kNumParameterFlags > 1) {
-    loop_body += IntConstant(compiler::target::kNumParameterFlags);
-    loop_body += SmiBinaryOp(Token::kMUL, /*is_truncating=*/false);
+  LocalVariable* param_name = MakeTemporary("param_name");  // Read only.
+
+  // One additional local value on the stack within the loop body (param_name)
+  // that should be dropped after rejoining at loop_incr.
+  JoinEntryInstr* loop_incr = BuildJoinEntry();
+
+  // Now iterate over the ArgumentsDescriptor names and check for a match.
+  for (intptr_t i = 0; i < info.descriptor.NamedCount(); i++) {
+    const auto& name = String::ZoneHandle(Z, info.descriptor.NameAt(i));
+    loop_body += Constant(name);
+    loop_body += LoadLocal(param_name);
+    TargetEntryInstr *match, *mismatch;
+    loop_body += BranchIfEqual(&match, &mismatch);
+    loop_body.current = mismatch;
+
+    // We have a match, so go to the next name after incrementing the number
+    // of matched arguments. (No need to check for the required bit, as this
+    // parameter was provided.)
+    Fragment matched(match);
+    matched += LoadLocal(info.vars->current_num_processed);
+    matched += IntConstant(1);
+    matched += SmiBinaryOp(Token::kADD, /*is_truncating=*/true);
+    matched += StoreLocal(info.vars->current_num_processed);
+    matched += Drop();
+    matched += Goto(loop_incr);
   }
-  loop_body += SmiBinaryOp(Token::kSHR);
-  loop_body += IntConstant(1 << compiler::target::kRequiredNamedParameterFlag);
-  loop_body += SmiBinaryOp(Token::kBIT_AND);
-  loop_body += IntConstant(0);
-  TargetEntryInstr *not_set, *set;
-  loop_body += BranchIfEqual(&not_set, &set);
 
-  // Make a join entry for the increment at the end of the loop, so we can jump
-  // to it if we match one of the names in the ArgumentsDescriptor.
-  JoinEntryInstr* incr_index = BuildJoinEntry();
-  Fragment(not_set) + Goto(incr_index);
+  // None of the names in the arguments descriptor matched, so check if this
+  // is a required parameter.
+  loop_body += TestClosureFunctionNamedParameterRequired(
+      info,
+      /*set=*/Goto(info.throw_no_such_method),
+      /*not_set=*/{});
 
-  Fragment check_names(set);
-  if (descriptor.NamedCount() > 0) {
-    // First load the name we need to check against into :expr_temp.
-    check_names += LoadLocal(vars->parameter_names);
-    check_names += LoadLocal(vars->current_param_index);
-    check_names += LoadLocal(vars->num_fixed_params);
-    check_names += SmiBinaryOp(Token::kADD, /*is_truncating=*/true);
-    check_names += LoadIndexed(compiler::target::kWordSize);
-    check_names += StoreLocal(TokenPosition::kNoSource, temp);
-    check_names += Drop();
-    // Now iterate over the names in the ArgumentsDescriptor and add a check
-    // against each that goes to t he next loop iteration if the name is found.
-    for (intptr_t i = 0; i < descriptor.NamedCount(); i++) {
-      const auto& name = String::ZoneHandle(Z, descriptor.NameAt(i));
-      check_names += LoadLocal(temp);
-      check_names += Constant(name);
-      TargetEntryInstr *str_equal, *str_neq;
-      check_names += BranchIfEqual(&str_equal, &str_neq);
-      check_names.current = str_neq;
+  loop_body += Goto(loop_incr);
 
-      Fragment(str_equal) + Goto(incr_index);
-    }
-  }
-  // None of the names in the arguments descriptor matched, so throw NSM.
-  check_names += Goto(nsm);
+  Fragment incr_index(loop_incr);
+  incr_index += DropTemporary(&param_name);
+  incr_index += LoadLocal(info.vars->current_param_index);
+  incr_index += IntConstant(1);
+  incr_index += SmiBinaryOp(Token::kADD, /*is_truncating=*/true);
+  incr_index += StoreLocal(info.vars->current_param_index);
+  incr_index += Drop();
+  incr_index += Goto(loop);
 
-  // Increment the counter if the current parameter wasn't required or was
-  // required but provided.
-  loop_body.current = incr_index;
-  loop_body += LoadLocal(vars->current_param_index);
-  loop_body += IntConstant(1);
-  loop_body += SmiBinaryOp(Token::kADD, /*is_truncating=*/true);
-  loop_body += StoreLocal(TokenPosition::kNoSource, vars->current_param_index);
-  loop_body += Drop();
-  loop_body += Goto(loop);
+  Fragment check_processed(done);
+  check_processed += LoadLocal(info.vars->current_num_processed);
+  check_processed += IntConstant(info.descriptor.NamedCount());
+  TargetEntryInstr *all_processed, *bad_name;
+  check_processed += BranchIfEqual(&all_processed, &bad_name);
 
-  check_required.current = done;
-  return check_required;
+  // Didn't find a matching parameter name for at least one argument name.
+  Fragment(bad_name) + Goto(info.throw_no_such_method);
+
+  // Drop the temporaries at the end of the fragment.
+  check_names.current = all_processed;
+  check_names += LoadLocal(old_processed);
+  check_names += StoreLocal(info.vars->current_num_processed);
+  check_names += Drop();
+  check_names += DropTemporary(&old_processed);
+  check_names += LoadLocal(old_index);
+  check_names += StoreLocal(info.vars->current_param_index);
+  check_names += Drop();
+  check_names += DropTemporary(&old_index);
+  return check_names;
 }
 
 Fragment FlowGraphBuilder::BuildClosureCallArgumentsValidCheck(
-    LocalVariable* closure,
-    JoinEntryInstr* nsm) {
-  auto const vars = parsed_function_->dynamic_closure_call_vars();
-  ASSERT(vars != nullptr);
-  ASSERT(has_saved_args_desc_array());
-  const ArgumentsDescriptor descriptor(saved_args_desc_array());
-
-  LocalVariable* temp = parsed_function_->expression_temp_var();
-
+    const ClosureCallInfo& info) {
   Fragment check_entry;
   // We only need to check the length of any explicitly provided type arguments.
-  if (descriptor.TypeArgsLen() > 0) {
+  if (info.descriptor.TypeArgsLen() > 0) {
     Fragment check_type_args_length;
-    check_type_args_length += LoadLocal(closure);
-    check_type_args_length += LoadNativeField(Slot::Closure_function());
-    check_type_args_length += LoadNativeField(Slot::Function_type_parameters());
-    check_type_args_length += StoreLocal(TokenPosition::kNoSource, temp);
+    check_type_args_length += LoadLocal(info.type_parameters);
     TargetEntryInstr *null, *not_null;
     check_type_args_length += BranchIfNull(&null, &not_null);
     check_type_args_length.current = not_null;  // Continue in non-error case.
-
-    // The function is not generic.
-    Fragment(null) + Goto(nsm);
-
-    check_type_args_length += LoadLocal(temp);
+    check_type_args_length += LoadLocal(info.type_parameters);
     check_type_args_length += LoadNativeField(Slot::TypeArguments_length());
-    check_type_args_length += IntConstant(descriptor.TypeArgsLen());
+    check_type_args_length += IntConstant(info.descriptor.TypeArgsLen());
     TargetEntryInstr *equal, *not_equal;
     check_type_args_length += BranchIfEqual(&equal, &not_equal);
     check_type_args_length.current = equal;  // Continue in non-error case.
 
-    Fragment(not_equal) + Goto(nsm);
+    // The function is not generic.
+    Fragment(null) + Goto(info.throw_no_such_method);
+
+    // An incorrect number of type arguments were passed.
+    Fragment(not_equal) + Goto(info.throw_no_such_method);
 
     // Type arguments should not be provided if there are delayed type
     // arguments, as then the closure itself is not generic.
-    check_entry += TestDelayedTypeArgs(closure, /*present=*/Goto(nsm),
-                                       /*absent=*/check_type_args_length);
+    check_entry += TestDelayedTypeArgs(
+        info.closure, /*present=*/Goto(info.throw_no_such_method),
+        /*absent=*/check_type_args_length);
   }
 
-  check_entry += LoadLocal(vars->has_named_params);
+  check_entry += LoadLocal(info.has_named_params);
   TargetEntryInstr *has_named, *has_positional;
   check_entry += BranchIfTrue(&has_named, &has_positional);
   JoinEntryInstr* join_after_optional = BuildJoinEntry();
   check_entry.current = join_after_optional;
 
-  if (descriptor.NamedCount() > 0) {
+  if (info.descriptor.NamedCount() > 0) {
     // No reason to continue checking, as this function doesn't take named args.
-    Fragment(has_positional) + Goto(nsm);
+    Fragment(has_positional) + Goto(info.throw_no_such_method);
   } else {
     Fragment check_pos(has_positional);
-    check_pos += LoadLocal(vars->num_fixed_params);
-    check_pos += IntConstant(descriptor.PositionalCount());
+    check_pos += LoadLocal(info.num_fixed_params);
+    check_pos += IntConstant(info.descriptor.PositionalCount());
     check_pos += SmiRelationalOp(Token::kLTE);
     TargetEntryInstr *enough, *too_few;
     check_pos += BranchIfTrue(&enough, &too_few);
     check_pos.current = enough;
 
-    Fragment(too_few) + Goto(nsm);
+    Fragment(too_few) + Goto(info.throw_no_such_method);
 
-    check_pos += IntConstant(descriptor.PositionalCount());
-    check_pos += LoadLocal(vars->num_max_params);
+    check_pos += IntConstant(info.descriptor.PositionalCount());
+    check_pos += LoadLocal(info.num_max_params);
     check_pos += SmiRelationalOp(Token::kLTE);
     TargetEntryInstr *valid, *too_many;
     check_pos += BranchIfTrue(&valid, &too_many);
     check_pos.current = valid;
 
-    Fragment(too_many) + Goto(nsm);
+    Fragment(too_many) + Goto(info.throw_no_such_method);
 
     check_pos += Goto(join_after_optional);
   }
@@ -2208,90 +2232,114 @@
   Fragment check_named(has_named);
 
   TargetEntryInstr *same, *different;
-  check_named += LoadLocal(vars->num_fixed_params);
-  check_named += IntConstant(descriptor.PositionalCount());
+  check_named += LoadLocal(info.num_fixed_params);
+  check_named += IntConstant(info.descriptor.PositionalCount());
   check_named += BranchIfEqual(&same, &different);
   check_named.current = same;
 
-  Fragment(different) + Goto(nsm);
+  Fragment(different) + Goto(info.throw_no_such_method);
 
-  if (descriptor.NamedCount() > 0) {
-    check_named += IntConstant(descriptor.NamedCount());
-    check_named += LoadLocal(vars->num_opt_params);
+  if (info.descriptor.NamedCount() > 0) {
+    check_named += IntConstant(info.descriptor.NamedCount());
+    check_named += LoadLocal(info.num_opt_params);
     check_named += SmiRelationalOp(Token::kLTE);
     TargetEntryInstr *valid, *too_many;
     check_named += BranchIfTrue(&valid, &too_many);
     check_named.current = valid;
 
-    Fragment(too_many) + Goto(nsm);
+    Fragment(too_many) + Goto(info.throw_no_such_method);
   }
 
-  check_named += BuildClosureCallHasRequiredNamedArgumentsCheck(closure, nsm);
+  // Check the names for optional arguments. If applicable, also check that all
+  // required named parameters are provided.
+  check_named += BuildClosureCallNamedArgumentsCheck(info);
   check_named += Goto(join_after_optional);
 
+  check_entry.current = join_after_optional;
   return check_entry;
 }
 
-Fragment FlowGraphBuilder::BuildClosureCallNamedArgumentCheck(
-    LocalVariable* closure,
-    intptr_t pos,
-    JoinEntryInstr* nsm) {
-  auto const vars = parsed_function_->dynamic_closure_call_vars();
-  ASSERT(vars != nullptr);
-  ASSERT(has_saved_args_desc_array());
-  const ArgumentsDescriptor descriptor(saved_args_desc_array());
+Fragment FlowGraphBuilder::BuildDynamicClosureCallChecks(
+    LocalVariable* closure) {
+  ClosureCallInfo info(closure, BuildThrowNoSuchMethod(),
+                       saved_args_desc_array(),
+                       parsed_function_->dynamic_closure_call_vars());
 
-  // If this isn't a named argument, then don't build anything.
-  if (pos < descriptor.PositionalCount()) return Fragment();
-  const intptr_t named_pos = pos - descriptor.PositionalCount();
-  ASSERT(named_pos < descriptor.NamedCount());
+  // We extract all the packed fields here so code generation that puts unboxed
+  // integers on the expression stack even in unoptimized code is in one place.
+  auto const rep = Slot::Function_packed_fields().representation();
 
-  // Loop over the indexes of the named parameters of the function, checking
-  // whether the named parameter at that index is required. If it is, then
-  // check whether it matches any of the names in the ArgumentsDescriptor.
-  JoinEntryInstr* loop = BuildJoinEntry();
+  Fragment body;
+  body += LoadLocal(info.closure);
+  body += LoadNativeField(Slot::Closure_function());
+  info.function = MakeTemporary("function");
 
-  // We iterate from [0, num_named), not [num_fixed, num_named) because the
-  // flag mask and index is based off the named index, not the param index.
-  Fragment check_arg_name;
-  check_arg_name += LoadLocal(vars->num_fixed_params);
-  check_arg_name +=
-      StoreLocal(TokenPosition::kNoSource, vars->current_param_index);
-  check_arg_name += Drop();
-  check_arg_name += Goto(loop);
+  body += LoadLocal(info.function);
+  body += LoadNativeField(Slot::Function_packed_fields());
+  body +=
+      BuildExtractPackedFieldIntoSmi<Function::PackedNumFixedParameters>(rep);
+  info.num_fixed_params = MakeTemporary("num_fixed_params");
 
-  Fragment loop_check(loop);
-  loop_check += LoadLocal(vars->current_param_index);
-  loop_check += LoadLocal(vars->num_max_params);
-  loop_check += SmiRelationalOp(Token::kLT);
-  TargetEntryInstr *no_more, *more;
-  loop_check += BranchIfTrue(&more, &no_more);
+  body += LoadLocal(info.function);
+  body += LoadNativeField(Slot::Function_packed_fields());
+  body += BuildExtractPackedFieldIntoSmi<Function::PackedNumOptionalParameters>(
+      rep);
+  info.num_opt_params = MakeTemporary("num_opt_params");
 
-  JoinEntryInstr* done = BuildJoinEntry();
-  // None of the parameter names matched.
-  Fragment(no_more) + Goto(nsm);
+  body += LoadLocal(info.num_fixed_params);
+  body += LoadLocal(info.num_opt_params);
+  body += SmiBinaryOp(Token::kADD);
+  info.num_max_params = MakeTemporary("num_max_params");
 
-  Fragment loop_body(more);
-  loop_body += LoadLocal(vars->parameter_names);
-  loop_body += LoadLocal(vars->current_param_index);
-  loop_body += LoadIndexed(compiler::target::kWordSize);
-  loop_body += Constant(String::ZoneHandle(Z, descriptor.NameAt(named_pos)));
-  TargetEntryInstr *str_equal, *str_neq;
-  loop_body += BranchIfEqual(&str_equal, &str_neq);
+  body += LoadLocal(info.function);
+  body += LoadNativeField(Slot::Function_packed_fields());
+  body += BuildExtractPackedFieldIntoSmi<
+      Function::PackedHasNamedOptionalParameters>(rep);
+  body += IntConstant(0);
+  body += StrictCompare(Token::kNE_STRICT);
+  info.has_named_params = MakeTemporary("has_named_params");
 
-  Fragment(str_equal) + Goto(done);
+  if (I->null_safety() || info.descriptor.NamedCount() > 0) {
+    body += LoadLocal(info.function);
+    body += LoadNativeField(Slot::Function_parameter_names());
+    info.parameter_names = MakeTemporary("parameter_names");
+  }
 
-  // Increment the index and jump back to the loop check.
-  loop_body.current = str_neq;
-  loop_body += LoadLocal(vars->current_param_index);
-  loop_body += IntConstant(1);
-  loop_body += SmiBinaryOp(Token::kADD, /*is_truncating=*/true);
-  loop_body += StoreLocal(TokenPosition::kNoSource, vars->current_param_index);
-  loop_body += Drop();
-  loop_body += Goto(loop);
+  if (info.descriptor.TypeArgsLen() > 0) {
+    body += LoadLocal(info.function);
+    body += LoadNativeField(Slot::Function_type_parameters());
+    info.type_parameters = MakeTemporary("type_parameters");
+  }
 
-  check_arg_name.current = done;
-  return check_arg_name;
+  // Check that the shape of the arguments generally matches what the
+  // closure function expects. The only remaining non-type check after this
+  // is that the names for optional arguments are valid.
+  body += BuildClosureCallArgumentsValidCheck(info);
+
+  // TODO(dartbug.com/40813): Move checks that are currently compiled
+  // in the closure body to here, using the dynamic versions of
+  // AssertSubtype to typecheck the type arguments using the runtime types
+  // available in the closure object.
+
+  // TODO(dartbug.com/40813): Move checks that are currently compiled
+  // in the closure body to here, using the dynamic versions of
+  // AssertAssignable to typecheck the parameters using the runtime types
+  // available in the closure object.
+
+  // Drop all the read-only temporaries at the end of the fragment.
+  if (info.type_parameters != nullptr) {
+    body += DropTemporary(&info.type_parameters);
+  }
+  if (info.parameter_names != nullptr) {
+    body += DropTemporary(&info.parameter_names);
+  }
+  body += DropTemporary(&info.has_named_params);
+  body += DropTemporary(&info.num_max_params);
+  body += DropTemporary(&info.num_opt_params);
+  body += DropTemporary(&info.num_fixed_params);
+  body += DropTemporary(&info.function);
+
+  return body;
 }
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfInvokeFieldDispatcher(
@@ -2334,7 +2382,7 @@
 
   // Build any dynamic closure call checks before pushing arguments to the
   // final call on the stack to make debugging easier.
-  LocalVariable* closure = NULL;
+  LocalVariable* closure = nullptr;
   if (is_closure_call) {
     closure = parsed_function_->ParameterVariable(0);
     if (is_dynamic_call) {
@@ -2344,30 +2392,7 @@
       InlineBailout(
           "kernel::FlowGraphBuilder::BuildGraphOfInvokeFieldDispatcher");
 
-      // Init the variables we'll be using for dynamic call checking.
-      body += BuildDynamicCallVarsInit(closure);
-
-      JoinEntryInstr* nsm = BuildThrowNoSuchMethod();
-      // Check that the shape of the arguments generally matches what the
-      // closure function expects. The only remaining non-type check after this
-      // is that the names for optional arguments are valid.
-      body += BuildClosureCallArgumentsValidCheck(closure, nsm);
-
-      // TODO(dartbug.com/40813): Move checks that are currently compiled
-      // in the closure body to here, using the dynamic versions of
-      // AssertSubtype to typecheck the type arguments using the runtime types
-      // available in the closure object.
-
-      // TODO(dartbug.com/40813): Move checks that are currently compiled
-      // in the closure body to here, using the dynamic versions of
-      // AssertAssignable to typecheck the parameters using the runtime types
-      // available in the closure object.
-      //
-      // For now, we check that any named arguments have valid names.
-      for (intptr_t pos = descriptor.PositionalCount();
-           pos < descriptor.Count(); pos++) {
-        body += BuildClosureCallNamedArgumentCheck(closure, pos, nsm);
-      }
+      body += BuildDynamicClosureCallChecks(closure);
     }
   }
 
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.h b/runtime/vm/compiler/frontend/kernel_to_il.h
index 957807b..9db5a39 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.h
+++ b/runtime/vm/compiler/frontend/kernel_to_il.h
@@ -80,31 +80,32 @@
   FlowGraph* BuildGraphOfMethodExtractor(const Function& method);
   FlowGraph* BuildGraphOfNoSuchMethodDispatcher(const Function& function);
 
-  Fragment BuildDynamicCallVarsInit(LocalVariable* closure);
+  struct ClosureCallInfo;
+
+  // Tests whether the function parameter at the given index is required and
+  // branches to the appropriate fragment. Loads the parameter index to
+  // check from info.vars->current_param_index.
+  Fragment TestClosureFunctionNamedParameterRequired(
+      const ClosureCallInfo& info,
+      Fragment set,
+      Fragment not_set);
 
   // The BuildClosureCall...Check methods differs from the checks built in the
   // PrologueBuilder in that they are built for invoke field dispatchers,
   // where the ArgumentsDescriptor is known at compile time but the specific
   // closure function is retrieved at runtime.
 
-  // Builds checks that all required arguments are provided. Generates an empty
-  // fragment if null safety is not enabled.
-  Fragment BuildClosureCallHasRequiredNamedArgumentsCheck(
-      LocalVariable* closure,
-      JoinEntryInstr* nsm);
+  // Builds checks that the given named arguments have valid argument names
+  // and, in the case of null safe code, that all required named parameters
+  // are provided.
+  Fragment BuildClosureCallNamedArgumentsCheck(const ClosureCallInfo& info);
 
   // Builds checks for checking the arguments of a call are valid for the
-  // function retrieved at runtime from the closure. Checks almost all the
-  // same cases as Function::AreArgumentsValid, leaving only name checking
-  // for optional named arguments to be checked during argument type checking.
-  Fragment BuildClosureCallArgumentsValidCheck(LocalVariable* closure,
-                                               JoinEntryInstr* nsm);
+  // function retrieved at runtime from the closure.
+  Fragment BuildClosureCallArgumentsValidCheck(const ClosureCallInfo& info);
 
-  // Builds checks that the given named argument has a valid argument name.
-  // Returns the empty fragment for positional arguments.
-  Fragment BuildClosureCallNamedArgumentCheck(LocalVariable* closure,
-                                              intptr_t pos,
-                                              JoinEntryInstr* nsm);
+  // Main entry point for building checks.
+  Fragment BuildDynamicClosureCallChecks(LocalVariable* closure);
 
   FlowGraph* BuildGraphOfInvokeFieldDispatcher(const Function& function);
   FlowGraph* BuildGraphOfFfiTrampoline(const Function& function);
diff --git a/runtime/vm/compiler/frontend/scope_builder.cc b/runtime/vm/compiler/frontend/scope_builder.cc
index b91b32a..f28890b 100644
--- a/runtime/vm/compiler/frontend/scope_builder.cc
+++ b/runtime/vm/compiler/frontend/scope_builder.cc
@@ -441,7 +441,6 @@
 #define ADD_VAR(Name, _, __) scope_->AddVariable(vars->Name);
         FOR_EACH_DYNAMIC_CLOSURE_CALL_VARIABLE(ADD_VAR);
 #undef ADD_VAR
-        needs_expr_temp_ = true;
       }
       FALL_THROUGH;
     }
diff --git a/runtime/vm/parser.cc b/runtime/vm/parser.cc
index d3e0e47..9f873d9 100644
--- a/runtime/vm/parser.cc
+++ b/runtime/vm/parser.cc
@@ -345,8 +345,6 @@
   if (dynamic_closure_call_vars_ != nullptr) return dynamic_closure_call_vars_;
   dynamic_closure_call_vars_ = new (zone()) DynamicClosureCallVars();
 
-  const auto& type_Array = Type::ZoneHandle(zone(), Type::ArrayType());
-  const auto& type_Bool = Type::ZoneHandle(zone(), Type::BoolType());
   const auto& type_Smi = Type::ZoneHandle(zone(), Type::SmiType());
 #define INIT_FIELD(Name, TypeName, Symbol)                                     \
   dynamic_closure_call_vars_->Name = new (zone())                              \
diff --git a/runtime/vm/parser.h b/runtime/vm/parser.h
index 6ea6d2a..9c56692 100644
--- a/runtime/vm/parser.h
+++ b/runtime/vm/parser.h
@@ -243,15 +243,12 @@
   // method.
   bool IsGenericCovariantImplParameter(intptr_t i) const;
 
-  // Variables needed for the InvokeFieldDispatcher for dynamic closure calls.
+  // Variables needed for the InvokeFieldDispatcher for dynamic closure calls,
+  // because they are both read and written to by the builders.
   struct DynamicClosureCallVars : ZoneAllocated {
 #define FOR_EACH_DYNAMIC_CLOSURE_CALL_VARIABLE(V)                              \
-  V(current_param_index, Smi, CurrentParamIndex)                               \
-  V(has_named_params, Bool, HasNamed)                                          \
-  V(num_fixed_params, Smi, NumFixed)                                           \
-  V(num_opt_params, Smi, NumOpt)                                               \
-  V(num_max_params, Smi, MaxParams)                                            \
-  V(parameter_names, Array, ParameterNames)
+  V(current_num_processed, Smi, CurrentNumProcessed)                           \
+  V(current_param_index, Smi, CurrentParamIndex)
 
 #define DEFINE_FIELD(Name, _, __) LocalVariable* Name = nullptr;
     FOR_EACH_DYNAMIC_CLOSURE_CALL_VARIABLE(DEFINE_FIELD)
diff --git a/runtime/vm/symbols.h b/runtime/vm/symbols.h
index 9010987..80d6da1 100644
--- a/runtime/vm/symbols.h
+++ b/runtime/vm/symbols.h
@@ -108,12 +108,8 @@
   V(Double, "double")                                                          \
   V(Dynamic, "dynamic")                                                        \
   V(DynamicCall, "dyn:call")                                                   \
+  V(DynamicCallCurrentNumProcessedVar, ":dyn_call_current_num_processed")      \
   V(DynamicCallCurrentParamIndexVar, ":dyn_call_current_param_index")          \
-  V(DynamicCallHasNamedVar, ":dyn_call_has_named")                             \
-  V(DynamicCallMaxParamsVar, ":dyn_call_max_params")                           \
-  V(DynamicCallNumFixedVar, ":dyn_call_num_fixed")                             \
-  V(DynamicCallNumOptVar, ":dyn_call_num_opt")                                 \
-  V(DynamicCallParameterNamesVar, ":dyn_call_parameter_names")                 \
   V(DynamicPrefix, "dyn:")                                                     \
   V(EntryPointsTemp, ":entry_points_temp")                                     \
   V(EqualOperator, "==")                                                       \
diff --git a/tests/language/argument/assignability_function_typed_test.dart b/tests/language/argument/assignability_function_typed_test.dart
index fe17a15..b2d6e26 100644
--- a/tests/language/argument/assignability_function_typed_test.dart
+++ b/tests/language/argument/assignability_function_typed_test.dart
@@ -31,15 +31,15 @@
   f(intToObject);
   //^^^^^^^^^^^
   // [analyzer] COMPILE_TIME_ERROR.ARGUMENT_TYPE_NOT_ASSIGNABLE
-  // [cfe] The top level function has type 'Object Function(int)' that isn't of expected type 'num Function(num)'.
+  // [cfe] The argument type 'Object Function(int)' can't be assigned to the parameter type 'num Function(num)'.
   f(intToNum);
   //^^^^^^^^
   // [analyzer] COMPILE_TIME_ERROR.ARGUMENT_TYPE_NOT_ASSIGNABLE
-  // [cfe] The top level function has type 'num Function(int)' that isn't of expected type 'num Function(num)'.
+  // [cfe] The argument type 'num Function(int)' can't be assigned to the parameter type 'num Function(num)'.
   f(numToObject);
   //^^^^^^^^^^^
   // [analyzer] COMPILE_TIME_ERROR.ARGUMENT_TYPE_NOT_ASSIGNABLE
-  // [cfe] The top level function has type 'Object Function(num)' that isn't of expected type 'num Function(num)'.
+  // [cfe] The argument type 'Object Function(num)' can't be assigned to the parameter type 'num Function(num)'.
 
   // Ok.
   f(numToNum);
diff --git a/tests/language/async/return_types_test.dart b/tests/language/async/return_types_test.dart
index f378549..3de5491 100644
--- a/tests/language/async/return_types_test.dart
+++ b/tests/language/async/return_types_test.dart
@@ -19,7 +19,7 @@
   return "String";
   //     ^^^^^^^^
   // [analyzer] COMPILE_TIME_ERROR.RETURN_OF_INVALID_TYPE
-  // [cfe] A value of type 'String' can't be assigned to a variable of type 'FutureOr<int>'.
+  // [cfe] A value of type 'String' can't be returned from an async function with return type 'Future<int>'.
 }
 
 Future<int, String>
@@ -34,7 +34,7 @@
 // [error line 33, column 1, length 3]
 // [analyzer] COMPILE_TIME_ERROR.ILLEGAL_ASYNC_RETURN_TYPE
 foo5() async {
-// [error line 36, column 1, length 3]
+// [error line 36, column 1]
 // [cfe] Functions marked 'async' must have a return type assignable to 'Future'.
   return 3;
 }
diff --git a/tests/language/parameter/named_with_conversions_test.dart b/tests/language/parameter/named_with_conversions_test.dart
index 58e85f5..8818036 100644
--- a/tests/language/parameter/named_with_conversions_test.dart
+++ b/tests/language/parameter/named_with_conversions_test.dart
@@ -29,9 +29,9 @@
 }
 
 class HasMethod {
-  int calls;
+  int calls = 0;
 
-  HasMethod() : calls = 0 {}
+  HasMethod();
 
   foo(tag, [a = 10, b = 20]) {
     calls += 1;
@@ -46,7 +46,7 @@
 
 class HasField {
   int calls = 0;
-  var foo, foo2;
+  late final dynamic foo, foo2;
 
   HasField() {
     foo = makeFoo(this);
@@ -71,16 +71,6 @@
 }
 
 class NamedParametersWithConversionsTest {
-  static checkException(thunk) {
-    bool threw = false;
-    try {
-      thunk();
-    } catch (e) {
-      threw = true;
-    }
-    Expect.isTrue(threw);
-  }
-
   static testMethodCallSyntax(a) {
     a.foo('');
     a.foo('a', 111);
@@ -92,10 +82,12 @@
 
     Expect.equals(7, a.calls);
 
-    checkException(() => a.foo()); //                  Too few arguments.
-    checkException(() => a.foo('abc', 1, 2, 3)); //    Too many arguments.
-    checkException(() => a.foo2('c', c: 1)); //        Bad name.
-    checkException(() => a.foo2('c', a: 111, c: 1)); // Bad name.
+    Expect.throwsNoSuchMethodError(() => a.foo()); // Too few arguments.
+    Expect.throwsNoSuchMethodError(
+        () => a.foo('abc', 1, 2, 3)); //              Too many arguments.
+    Expect.throwsNoSuchMethodError(() => a.foo2('c', c: 1)); // Bad name.
+    Expect.throwsNoSuchMethodError(
+        () => a.foo2('c', a: 111, c: 1)); //                    Bad name.
 
     Expect.equals(7, a.calls);
   }
@@ -113,10 +105,11 @@
 
     Expect.equals(7, a.calls);
 
-    checkException(() => f()); //                   Too few arguments.
-    checkException(() => f('abc', 1, 2, 3)); //     Too many arguments.
-    checkException(() => f2('c', c: 1)); //         Bad name.
-    checkException(() => f2('c', a: 111, c: 1)); // Bad name.
+    Expect.throwsNoSuchMethodError(() => f()); // Too few arguments.
+    Expect.throwsNoSuchMethodError(
+        () => f('abc', 1, 2, 3)); //              Too many arguments.
+    Expect.throwsNoSuchMethodError(() => f2('c', c: 1)); //         Bad name.
+    Expect.throwsNoSuchMethodError(() => f2('c', a: 111, c: 1)); // Bad name.
 
     Expect.equals(7, a.calls);
   }
diff --git a/tests/language_2/parameter/named_with_conversions_test.dart b/tests/language_2/parameter/named_with_conversions_test.dart
index 14849e6..5b949e6 100644
--- a/tests/language_2/parameter/named_with_conversions_test.dart
+++ b/tests/language_2/parameter/named_with_conversions_test.dart
@@ -29,9 +29,9 @@
 }
 
 class HasMethod {
-  int calls;
+  int calls = 0;
 
-  HasMethod() : calls = 0 {}
+  HasMethod();
 
   foo(tag, [a = 10, b = 20]) {
     calls += 1;
@@ -45,11 +45,10 @@
 }
 
 class HasField {
-  int calls;
-  var foo, foo2;
+  int calls = 0;
+  dynamic foo, foo2;
 
   HasField() {
-    calls = 0;
     foo = makeFoo(this);
     foo2 = makeFoo2(this);
   }
@@ -72,16 +71,6 @@
 }
 
 class NamedParametersWithConversionsTest {
-  static checkException(thunk) {
-    bool threw = false;
-    try {
-      thunk();
-    } catch (e) {
-      threw = true;
-    }
-    Expect.isTrue(threw);
-  }
-
   static testMethodCallSyntax(a) {
     a.foo('');
     a.foo('a', 111);
@@ -93,10 +82,12 @@
 
     Expect.equals(7, a.calls);
 
-    checkException(() => a.foo()); //                  Too few arguments.
-    checkException(() => a.foo('abc', 1, 2, 3)); //    Too many arguments.
-    checkException(() => a.foo2('c', c: 1)); //        Bad name.
-    checkException(() => a.foo2('c', a: 111, c: 1)); // Bad name.
+    Expect.throwsNoSuchMethodError(() => a.foo()); // Too few arguments.
+    Expect.throwsNoSuchMethodError(
+        () => a.foo('abc', 1, 2, 3)); //              Too many arguments.
+    Expect.throwsNoSuchMethodError(() => a.foo2('c', c: 1)); // Bad name.
+    Expect.throwsNoSuchMethodError(
+        () => a.foo2('c', a: 111, c: 1)); //                    Bad name.
 
     Expect.equals(7, a.calls);
   }
@@ -114,10 +105,11 @@
 
     Expect.equals(7, a.calls);
 
-    checkException(() => f()); //                   Too few arguments.
-    checkException(() => f('abc', 1, 2, 3)); //     Too many arguments.
-    checkException(() => f2('c', c: 1)); //         Bad name.
-    checkException(() => f2('c', a: 111, c: 1)); // Bad name.
+    Expect.throwsNoSuchMethodError(() => f()); // Too few arguments.
+    Expect.throwsNoSuchMethodError(
+        () => f('abc', 1, 2, 3)); //              Too many arguments.
+    Expect.throwsNoSuchMethodError(() => f2('c', c: 1)); //         Bad name.
+    Expect.throwsNoSuchMethodError(() => f2('c', a: 111, c: 1)); // Bad name.
 
     Expect.equals(7, a.calls);
   }
diff --git a/tools/VERSION b/tools/VERSION
index 4af5629..b2782a7 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 10
 PATCH 0
-PRERELEASE 111
+PRERELEASE 112
 PRERELEASE_PATCH 0
\ No newline at end of file