[parser] Parse record literals

This is the first stab at implementing the record expressions from
https://github.com/dart-lang/language/blob/master/working/0546-patterns/records-feature-specification.md

Change-Id: I2adb6cb3cd50d4ee45e144e86ec7011d046f6170
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/253783
Commit-Queue: Jens Johansen <jensj@google.com>
Reviewed-by: Johnni Winther <johnniwinther@google.com>
Reviewed-by: Michael Thomsen <mit@google.com>
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>

pkg/_fe_analyzer_shared/lib/src/parser/forwarding_listener.dart

@@ -1569,6 +1569,11 @@ class ForwardingListener implements Listener {
     listener?.handleNamedArgument(colon);
   }
 
+  @override
+  void handleNamedRecordField(Token colon) {
+    listener?.handleNamedRecordField(colon);
+  }
+
   @override
   void handleNamedMixinApplicationWithClause(Token withKeyword) {
     listener?.handleNamedMixinApplicationWithClause(withKeyword);
@@ -1685,8 +1690,18 @@ class ForwardingListener implements Listener {
   }
 
   @override
-  void handleParenthesizedExpression(Token token) {
-    listener?.handleParenthesizedExpression(token);
+  void beginParenthesizedExpressionOrRecordLiteral(Token token) {
+    listener?.beginParenthesizedExpressionOrRecordLiteral(token);
+  }
+
+  @override
+  void endRecordLiteral(Token token, int count) {
+    listener?.endRecordLiteral(token, count);
+  }
+
+  @override
+  void endParenthesizedExpression(Token token) {
+    listener?.endParenthesizedExpression(token);
   }
 
   @override

pkg/_fe_analyzer_shared/lib/src/parser/identifier_context.dart

@@ -255,6 +255,12 @@ abstract class IdentifierContext {
   static const NamedArgumentReferenceIdentifierContext namedArgumentReference =
       const NamedArgumentReferenceIdentifierContext();
 
+  /// Identifier is a reference to a named record field
+  /// (e.g. `foo` in `(42, foo: 42);`.
+  static const NamedRecordFieldReferenceIdentifierContext
+      namedRecordFieldReference =
+      const NamedRecordFieldReferenceIdentifierContext();
+
   /// Identifier is a name being declared by a local variable declaration.
   static const LocalVariableDeclarationIdentifierContext
       localVariableDeclaration =

pkg/_fe_analyzer_shared/lib/src/parser/identifier_context_impl.dart

@@ -1020,6 +1020,42 @@ class NamedArgumentReferenceIdentifierContext extends IdentifierContext {
   }
 }
 
+/// See [IdentifierContext.namedRecordFieldReference].
+/// Initially this is just a copy of NamedArgumentReferenceIdentifierContext.
+class NamedRecordFieldReferenceIdentifierContext extends IdentifierContext {
+  const NamedRecordFieldReferenceIdentifierContext()
+      : super('namedRecordFieldReference', allowedInConstantExpression: true);
+
+  @override
+  Token ensureIdentifier(Token token, Parser parser) {
+    Token identifier = token.next!;
+    assert(identifier.kind != IDENTIFIER_TOKEN);
+    if (identifier.isIdentifier) {
+      checkAsyncAwaitYieldAsIdentifier(identifier, parser);
+      return identifier;
+    }
+
+    // Recovery
+    if (isOneOfOrEof(identifier, const [':'])) {
+      identifier = parser.insertSyntheticIdentifier(token, this,
+          message: codes.templateExpectedIdentifier.withArguments(identifier));
+    } else {
+      if (!identifier.isKeywordOrIdentifier) {
+        parser.reportRecoverableErrorWithToken(
+            identifier, codes.templateExpectedIdentifier);
+        // When in doubt, consume the token to ensure we make progress
+        // but insert a synthetic identifier to satisfy listeners.
+        identifier = parser.rewriter.insertSyntheticIdentifier(identifier);
+      } else {
+        // Use the keyword as the identifier.
+        parser.reportRecoverableErrorWithToken(
+            identifier, codes.templateExpectedIdentifierButGotKeyword);
+      }
+    }
+    return identifier;
+  }
+}
+
 /// See [IdentifierContext.topLevelFunctionDeclaration]
 /// and [IdentifierContext.topLevelVariableDeclaration].
 class TopLevelDeclarationIdentifierContext extends IdentifierContext {

pkg/_fe_analyzer_shared/lib/src/parser/listener.dart

@@ -1692,6 +1692,10 @@ class Listener implements UnescapeErrorListener {
     logEvent("NamedArgument");
   }
 
+  void handleNamedRecordField(Token colon) {
+    logEvent("NamedRecordField");
+  }
+
   void beginNewExpression(Token token) {}
 
   void endNewExpression(Token token) {
@@ -1746,10 +1750,19 @@ class Listener implements UnescapeErrorListener {
     logEvent("ParenthesizedCondition");
   }
 
-  /// Handle a parenthesized expression.
+  /// Starts a parenthesized expression or a record literal. Will be ended with
+  /// either [endParenthesizedExpression] or [endRecordLiteral].
+  void beginParenthesizedExpressionOrRecordLiteral(Token token) {}
+
+  /// Ends a record literal with [count] entries.
+  void endRecordLiteral(Token token, int count) {
+    logEvent("RecordLiteral");
+  }
+
+  /// End a parenthesized expression.
   /// These may be within the condition expression of a control structure
   /// but will not be the condition of a control structure.
-  void handleParenthesizedExpression(Token token) {
+  void endParenthesizedExpression(Token token) {
     logEvent("ParenthesizedExpression");
   }
 

pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart

@@ -5852,7 +5852,7 @@ class Parser {
         // Fall through to the recovery code.
       }
     } else if (kind == OPEN_PAREN_TOKEN) {
-      return parseParenthesizedExpressionOrFunctionLiteral(token);
+      return parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(token);
     } else if (kind == OPEN_SQUARE_BRACKET_TOKEN ||
         optional('[]', token.next!)) {
       listener.handleNoTypeArguments(token.next!);
@@ -5871,12 +5871,14 @@ class Parser {
     return parseSend(token, context);
   }
 
-  Token parseParenthesizedExpressionOrFunctionLiteral(Token token) {
+  Token parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(
+      Token token) {
     Token next = token.next!;
     assert(optional('(', next));
-    Token nextToken = next.endGroup!.next!;
-    int kind = nextToken.kind;
+
     if (mayParseFunctionExpressions) {
+      Token nextToken = next.endGroup!.next!;
+      int kind = nextToken.kind;
       if ((identical(kind, FUNCTION_TOKEN) ||
           identical(kind, OPEN_CURLY_BRACKET_TOKEN))) {
         listener.handleNoTypeVariables(next);
@@ -5901,7 +5903,7 @@ class Parser {
     }
     bool old = mayParseFunctionExpressions;
     mayParseFunctionExpressions = true;
-    token = parseParenthesizedExpression(token);
+    token = parseParenthesizedExpressionOrRecordLiteral(token);
     mayParseFunctionExpressions = old;
     return token;
   }
@@ -5919,15 +5921,59 @@ class Parser {
     return token;
   }
 
-  Token parseParenthesizedExpression(Token token) {
+  Token parseParenthesizedExpressionOrRecordLiteral(Token token) {
     Token begin = token.next!;
-    token = parseExpressionInParenthesis(token);
-    listener.handleParenthesizedExpression(begin);
-    return token;
-  }
+    assert(optional('(', begin));
+    listener.beginParenthesizedExpressionOrRecordLiteral(begin);
 
-  Token parseExpressionInParenthesis(Token token) {
-    return parseExpressionInParenthesisRest(token.next!);
+    // For parsing of parenthesized expression we need parity with
+    // parseExpressionInParenthesisRest used in ensureParenthesizedCondition.
+
+    token = begin;
+    int count = 0;
+    bool wasRecord = false;
+    while (true) {
+      Token next = token.next!;
+      if (count > 0 && optional(')', next)) {
+        // TODO(jensj): Possibly bail out even if count is 0 and give some
+        // specific error.
+        break;
+      }
+      Token? colon = null;
+      if (optional(':', next.next!) || /* recovery */ optional(':', next)) {
+        // Record with named expression.
+        wasRecord = true;
+        token = ensureIdentifier(
+          token,
+          IdentifierContext.namedRecordFieldReference,
+        ).next!;
+        colon = token;
+      }
+      token = parseExpression(token);
+      next = token.next!;
+      if (colon != null) listener.handleNamedRecordField(colon);
+      ++count;
+      if (!optional(',', next)) {
+        // TODO(jensj): Possible more specific recovery.
+        break;
+      } else {
+        // It is a comma, i.e. it's a record.
+        wasRecord = true;
+      }
+      token = next;
+    }
+    token = ensureCloseParen(token, begin);
+    assert(optional(')', token));
+
+    assert(wasRecord || count <= 1);
+
+    if (wasRecord) {
+      listener.endRecordLiteral(begin, count);
+    } else {
+      listener.endParenthesizedExpression(begin);
+    }
+
+    return token;
   }
 
   Token parseExpressionInParenthesisRest(Token token) {

pkg/_fe_analyzer_shared/lib/src/parser/stack_listener.dart

@@ -431,7 +431,12 @@ abstract class StackListener extends Listener {
   }
 
   @override
-  void handleParenthesizedExpression(Token token) {
+  void endRecordLiteral(Token token, int count) {
+    debugEvent("RecordLiteral");
+  }
+
+  @override
+  void endParenthesizedExpression(Token token) {
     debugEvent("ParenthesizedExpression");
   }
 

pkg/analysis_server/test/lsp/type_definition_test.dart

@@ -123,7 +123,7 @@ class [[A]] {}
   Future<void> test_parameter() async {
     final contents = '''
 void f(String a) {
-  void f([['te^st']]);
+  f([['te^st']]);
 }
 ''';
 
@@ -135,7 +135,7 @@ void f(String a) {
   Future<void> test_parameterName() async {
     final contents = '''
 void f({String a}) {
-  void f([[a^]]: 'test');
+  f([[a^]]: 'test');
 }
 ''';
 

pkg/analyzer/lib/src/dart/analysis/driver.dart

@@ -85,7 +85,7 @@ import 'package:analyzer/src/util/performance/operation_performance.dart';
 /// TODO(scheglov) Clean up the list of implicitly analyzed files.
 class AnalysisDriver implements AnalysisDriverGeneric {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 237;
+  static const int DATA_VERSION = 238;
 
   /// The number of exception contexts allowed to write. Once this field is
   /// zero, we stop writing any new exception contexts in this process.

pkg/analyzer/lib/src/dart/analysis/experiments.g.dart

@@ -33,6 +33,7 @@ final _knownFeatures = <String, ExperimentalFeature>{
   EnableString.non_nullable: ExperimentalFeatures.non_nullable,
   EnableString.nonfunction_type_aliases:
       ExperimentalFeatures.nonfunction_type_aliases,
+  EnableString.records: ExperimentalFeatures.records,
   EnableString.set_literals: ExperimentalFeatures.set_literals,
   EnableString.spread_collections: ExperimentalFeatures.spread_collections,
   EnableString.super_parameters: ExperimentalFeatures.super_parameters,
@@ -87,6 +88,9 @@ class EnableString {
   /// String to enable the experiment "nonfunction-type-aliases"
   static const String nonfunction_type_aliases = 'nonfunction-type-aliases';
 
+  /// String to enable the experiment "records"
+  static const String records = 'records';
+
   /// String to enable the experiment "set-literals"
   static const String set_literals = 'set-literals';
 
@@ -254,8 +258,18 @@ class ExperimentalFeatures {
     releaseVersion: Version.parse('2.13.0'),
   );
 
-  static final set_literals = ExperimentalFeature(
+  static final records = ExperimentalFeature(
     index: 14,
+    enableString: EnableString.records,
+    isEnabledByDefault: IsEnabledByDefault.records,
+    isExpired: IsExpired.records,
+    documentation: 'Records',
+    experimentalReleaseVersion: null,
+    releaseVersion: null,
+  );
+
+  static final set_literals = ExperimentalFeature(
+    index: 15,
     enableString: EnableString.set_literals,
     isEnabledByDefault: IsEnabledByDefault.set_literals,
     isExpired: IsExpired.set_literals,
@@ -265,7 +279,7 @@ class ExperimentalFeatures {
   );
 
   static final spread_collections = ExperimentalFeature(
-    index: 15,
+    index: 16,
     enableString: EnableString.spread_collections,
     isEnabledByDefault: IsEnabledByDefault.spread_collections,
     isExpired: IsExpired.spread_collections,
@@ -275,7 +289,7 @@ class ExperimentalFeatures {
   );
 
   static final super_parameters = ExperimentalFeature(
-    index: 16,
+    index: 17,
     enableString: EnableString.super_parameters,
     isEnabledByDefault: IsEnabledByDefault.super_parameters,
     isExpired: IsExpired.super_parameters,
@@ -285,7 +299,7 @@ class ExperimentalFeatures {
   );
 
   static final test_experiment = ExperimentalFeature(
-    index: 17,
+    index: 18,
     enableString: EnableString.test_experiment,
     isEnabledByDefault: IsEnabledByDefault.test_experiment,
     isExpired: IsExpired.test_experiment,
@@ -296,7 +310,7 @@ class ExperimentalFeatures {
   );
 
   static final triple_shift = ExperimentalFeature(
-    index: 18,
+    index: 19,
     enableString: EnableString.triple_shift,
     isEnabledByDefault: IsEnabledByDefault.triple_shift,
     isExpired: IsExpired.triple_shift,
@@ -306,7 +320,7 @@ class ExperimentalFeatures {
   );
 
   static final value_class = ExperimentalFeature(
-    index: 19,
+    index: 20,
     enableString: EnableString.value_class,
     isEnabledByDefault: IsEnabledByDefault.value_class,
     isExpired: IsExpired.value_class,
@@ -316,7 +330,7 @@ class ExperimentalFeatures {
   );
 
   static final variance = ExperimentalFeature(
-    index: 20,
+    index: 21,
     enableString: EnableString.variance,
     isEnabledByDefault: IsEnabledByDefault.variance,
     isExpired: IsExpired.variance,
@@ -371,6 +385,9 @@ class IsEnabledByDefault {
   /// Default state of the experiment "nonfunction-type-aliases"
   static const bool nonfunction_type_aliases = true;
 
+  /// Default state of the experiment "records"
+  static const bool records = false;
+
   /// Default state of the experiment "set-literals"
   static const bool set_literals = true;
 
@@ -439,6 +456,9 @@ class IsExpired {
   /// Expiration status of the experiment "nonfunction-type-aliases"
   static const bool nonfunction_type_aliases = true;
 
+  /// Expiration status of the experiment "records"
+  static const bool records = false;
+
   /// Expiration status of the experiment "set-literals"
   static const bool set_literals = true;
 
@@ -512,6 +532,9 @@ mixin _CurrentState {
   bool get nonfunction_type_aliases =>
       isEnabled(ExperimentalFeatures.nonfunction_type_aliases);
 
+  /// Current state for the flag "records"
+  bool get records => isEnabled(ExperimentalFeatures.records);
+
   /// Current state for the flag "set-literals"
   bool get set_literals => isEnabled(ExperimentalFeatures.set_literals);
 

pkg/analyzer/lib/src/fasta/ast_builder.dart

@@ -2345,6 +2345,16 @@ class AstBuilder extends StackListener {
         popTypedList2<FormalParameter>(count), leftDelimeter, rightDelimeter));
   }
 
+  @override
+  void endParenthesizedExpression(Token leftParenthesis) {
+    assert(optional('(', leftParenthesis));
+    debugEvent("ParenthesizedExpression");
+
+    var expression = pop() as Expression;
+    push(ast.parenthesizedExpression(
+        leftParenthesis, expression, leftParenthesis.endGroup!));
+  }
+
   @override
   void endPart(Token partKeyword, Token semicolon) {
     assert(optional('part', partKeyword));
@@ -2395,6 +2405,29 @@ class AstBuilder extends StackListener {
     );
   }
 
+  @override
+  void endRecordLiteral(Token token, int count) {
+    debugEvent("RecordLiteral");
+    // TODO: Actual implementation of record literals.
+
+    _reportFeatureNotEnabled(
+      feature: ExperimentalFeatures.records,
+      startToken: token,
+    );
+
+    // Pretend that the record literal is a list literal as the record literal
+    // isn't implemented yet.
+
+    var elements = popTypedList<Expression>(count) ?? const [];
+
+    List<Expression> expressions = <Expression>[];
+    for (var elem in elements) {
+      expressions.add(elem);
+    }
+
+    push(ast.listLiteral(null, null, token, expressions, token));
+  }
+
   @override
   void endRedirectingFactoryBody(Token equalToken, Token endToken) {
     assert(optional('=', equalToken));
@@ -3931,6 +3964,10 @@ class AstBuilder extends StackListener {
     push(ast.withClause(withKeyword, mixinTypes));
   }
 
+  @override
+  // TODO: Handle directly.
+  void handleNamedRecordField(Token colon) => handleNamedArgument(colon);
+
   @override
   void handleNativeClause(Token nativeToken, bool hasName) {
     debugEvent("NativeClause");
@@ -4041,17 +4078,7 @@ class AstBuilder extends StackListener {
   @override
   void handleParenthesizedCondition(Token leftParenthesis) {
     // TODO(danrubel): Implement rather than forwarding.
-    handleParenthesizedExpression(leftParenthesis);
-  }
-
-  @override
-  void handleParenthesizedExpression(Token leftParenthesis) {
-    assert(optional('(', leftParenthesis));
-    debugEvent("ParenthesizedExpression");
-
-    var expression = pop() as Expression;
-    push(ast.parenthesizedExpression(
-        leftParenthesis, expression, leftParenthesis.endGroup!));
+    endParenthesizedExpression(leftParenthesis);
   }
 
   @override

pkg/analyzer/tool/summary/mini_ast.dart

@@ -537,6 +537,10 @@ class MiniAstBuilder extends StackListener {
     debugEvent("NamedMixinApplicationWithClause");
   }
 
+  @override
+  // TODO: Handle directly.
+  void handleNamedRecordField(Token colon) => handleNamedArgument(colon);
+
   @override
   void handleNativeClause(Token nativeToken, bool hasName) {
     debugEvent("NativeClause");

pkg/front_end/lib/src/api_prototype/experimental_flags_generated.dart

@@ -171,6 +171,14 @@ class ExperimentalFlag {
       experimentEnabledVersion: const Version(2, 13),
       experimentReleasedVersion: const Version(2, 13));
 
+  static const ExperimentalFlag records = const ExperimentalFlag(
+      name: 'records',
+      isEnabledByDefault: false,
+      isExpired: false,
+      enabledVersion: const Version(2, 19),
+      experimentEnabledVersion: const Version(2, 19),
+      experimentReleasedVersion: const Version(2, 19));
+
   static const ExperimentalFlag setLiterals = const ExperimentalFlag(
       name: 'set-literals',
       isEnabledByDefault: true,
@@ -334,6 +342,10 @@ class GlobalFeatures {
   GlobalFeature get nonfunctionTypeAliases => _nonfunctionTypeAliases ??=
       _computeGlobalFeature(ExperimentalFlag.nonfunctionTypeAliases);
 
+  GlobalFeature? _records;
+  GlobalFeature get records =>
+      _records ??= _computeGlobalFeature(ExperimentalFlag.records);
+
   GlobalFeature? _setLiterals;
   GlobalFeature get setLiterals =>
       _setLiterals ??= _computeGlobalFeature(ExperimentalFlag.setLiterals);
@@ -456,6 +468,11 @@ class LibraryFeatures {
           canonicalUri,
           libraryVersion);
 
+  LibraryFeature? _records;
+  LibraryFeature get records =>
+      _records ??= globalFeatures._computeLibraryFeature(
+          ExperimentalFlag.records, canonicalUri, libraryVersion);
+
   LibraryFeature? _setLiterals;
   LibraryFeature get setLiterals =>
       _setLiterals ??= globalFeatures._computeLibraryFeature(
@@ -524,6 +541,8 @@ ExperimentalFlag? parseExperimentalFlag(String flag) {
       return ExperimentalFlag.nonNullable;
     case "nonfunction-type-aliases":
       return ExperimentalFlag.nonfunctionTypeAliases;
+    case "records":
+      return ExperimentalFlag.records;
     case "set-literals":
       return ExperimentalFlag.setLiterals;
     case "spread-collections":
@@ -571,6 +590,7 @@ final Map<ExperimentalFlag, bool> defaultExperimentalFlags = {
   ExperimentalFlag.nonNullable: ExperimentalFlag.nonNullable.isEnabledByDefault,
   ExperimentalFlag.nonfunctionTypeAliases:
       ExperimentalFlag.nonfunctionTypeAliases.isEnabledByDefault,
+  ExperimentalFlag.records: ExperimentalFlag.records.isEnabledByDefault,
   ExperimentalFlag.setLiterals: ExperimentalFlag.setLiterals.isEnabledByDefault,
   ExperimentalFlag.spreadCollections:
       ExperimentalFlag.spreadCollections.isEnabledByDefault,

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

@@ -69,7 +69,13 @@ import '../builder/void_type_declaration_builder.dart';
 import '../constant_context.dart' show ConstantContext;
 import '../dill/dill_library_builder.dart' show DillLibraryBuilder;
 import '../fasta_codes.dart' as fasta;
-import '../fasta_codes.dart' show LocatedMessage, Message, Template, noLength;
+import '../fasta_codes.dart'
+    show
+        LocatedMessage,
+        Message,
+        Template,
+        noLength,
+        templateExperimentDisabled;
 import '../identifiers.dart'
     show Identifier, InitializedIdentifier, QualifiedName, flattenName;
 import '../messages.dart' as messages show getLocationFromUri;
@@ -2258,7 +2264,7 @@ class BodyBuilder extends StackListenerImpl
   }
 
   @override
-  void handleParenthesizedExpression(Token token) {
+  void endParenthesizedExpression(Token token) {
     assert(checkState(token, [
       unionOfKinds([
         ValueKinds.Expression,
@@ -3951,6 +3957,26 @@ class BodyBuilder extends StackListenerImpl
     push(node);
   }
 
+  @override
+  void endRecordLiteral(Token token, int count) {
+    debugEvent("RecordLiteral");
+
+    addProblem(
+        templateExperimentDisabled.withArguments(ExperimentalFlag.records.name),
+        token.offset,
+        noLength);
+
+    // TODO: Actual implementation of record literals.
+    // For now we pretend it's an empty list.
+    for (int i = count - 1; i >= 0; i--) {
+      pop();
+    }
+    ListLiteral node = forest.createListLiteral(
+        TreeNode.noOffset, implicitTypeArgument, [],
+        isConst: constantContext == ConstantContext.inferred);
+    push(node);
+  }
+
   void buildLiteralSet(List<TypeBuilder>? typeArguments, Token? constKeyword,
       Token leftBrace, List<dynamic>? setOrMapEntries) {
     DartType typeArgument;
@@ -5949,6 +5975,10 @@ class BodyBuilder extends StackListenerImpl
     }
   }
 
+  @override
+  // TODO: Handle directly.
+  void handleNamedRecordField(Token colon) => handleNamedArgument(colon);
+
   @override
   void endFunctionName(Token beginToken, Token token) {
     debugEvent("FunctionName");

pkg/front_end/lib/src/fasta/kernel/macro/annotation_parser.dart

@@ -318,6 +318,10 @@ class _MacroListener implements Listener {
     }
   }
 
+  @override
+  // TODO: Handle directly.
+  void handleNamedRecordField(Token colon) => handleNamedArgument(colon);
+
   @override
   void handleLiteralNull(Token token) {
     push(new _PrimitiveValueNode(null));
@@ -1917,7 +1921,17 @@ class _MacroListener implements Listener {
   }
 
   @override
-  void handleParenthesizedExpression(Token token) {
+  void beginParenthesizedExpressionOrRecordLiteral(Token token) {
+    _unhandled();
+  }
+
+  @override
+  void endRecordLiteral(Token token, int count) {
+    _unhandled();
+  }
+
+  @override
+  void endParenthesizedExpression(Token token) {
     _unhandled();
   }
 

pkg/front_end/lib/src/fasta/source/diet_listener.dart

@@ -193,6 +193,12 @@ class DietListener extends StackListenerImpl {
     pop(); // Named argument name.
   }
 
+  @override
+  void handleNamedRecordField(Token colon) {
+    debugEvent("NamedRecordField");
+    pop(); // Named record field name.
+  }
+
   @override
   void handleClassWithClause(Token withKeyword) {
     debugEvent("ClassWithClause");

pkg/front_end/lib/src/fasta/source/outline_builder.dart

@@ -2009,6 +2009,13 @@ class OutlineBuilder extends StackListenerImpl {
     pop(); // Named argument name.
   }
 
+  @override
+  void handleNamedRecordField(Token colon) {
+    debugEvent("NamedRecordField");
+    pop(); // Named record field offset.
+    pop(); // Named record field name.
+  }
+
   @override
   void endNamedMixinApplication(Token beginToken, Token classKeyword,
       Token equals, Token? implementsKeyword, Token endToken) {

pkg/front_end/lib/src/fasta/util/parser_ast.dart

@@ -1553,6 +1553,10 @@ class ParserASTListener extends AbstractParserAstListener {
             (end == "InvalidYieldStatement")) {
           // beginYieldStatement is ended by either endYieldStatement or
           // endInvalidYieldStatement.
+        } else if (begin == "ParenthesizedExpressionOrRecordLiteral" &&
+            (end == "ParenthesizedExpression" || end == "RecordLiteral")) {
+          // beginParenthesizedExpressionOrRecordLiteral is ended by either
+          // endParenthesizedExpression or endRecordLiteral.
         } else {
           throw "Unknown combination: begin$begin and end$end";
         }

pkg/front_end/lib/src/fasta/util/parser_ast_helper.dart

@@ -2293,6 +2293,13 @@ abstract class AbstractParserAstListener implements Listener {
     seen(data);
   }
 
+  @override
+  void handleNamedRecordField(Token colon) {
+    NamedRecordFieldHandle data =
+        new NamedRecordFieldHandle(ParserAstType.HANDLE, colon: colon);
+    seen(data);
+  }
+
   @override
   void beginNewExpression(Token token) {
     NewExpressionBegin data =
@@ -2383,9 +2390,24 @@ abstract class AbstractParserAstListener implements Listener {
   }
 
   @override
-  void handleParenthesizedExpression(Token token) {
-    ParenthesizedExpressionHandle data =
-        new ParenthesizedExpressionHandle(ParserAstType.HANDLE, token: token);
+  void beginParenthesizedExpressionOrRecordLiteral(Token token) {
+    ParenthesizedExpressionOrRecordLiteralBegin data =
+        new ParenthesizedExpressionOrRecordLiteralBegin(ParserAstType.BEGIN,
+            token: token);
+    seen(data);
+  }
+
+  @override
+  void endRecordLiteral(Token token, int count) {
+    RecordLiteralEnd data =
+        new RecordLiteralEnd(ParserAstType.END, token: token, count: count);
+    seen(data);
+  }
+
+  @override
+  void endParenthesizedExpression(Token token) {
+    ParenthesizedExpressionEnd data =
+        new ParenthesizedExpressionEnd(ParserAstType.END, token: token);
     seen(data);
   }
 
@@ -6733,6 +6755,18 @@ class NamedArgumentHandle extends ParserAstNode {
       };
 }
 
+class NamedRecordFieldHandle extends ParserAstNode {
+  final Token colon;
+
+  NamedRecordFieldHandle(ParserAstType type, {required this.colon})
+      : super("NamedRecordField", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "colon": colon,
+      };
+}
+
 class NewExpressionBegin extends ParserAstNode {
   final Token token;
 
@@ -6886,10 +6920,38 @@ class ParenthesizedConditionHandle extends ParserAstNode {
       };
 }
 
-class ParenthesizedExpressionHandle extends ParserAstNode {
+class ParenthesizedExpressionOrRecordLiteralBegin extends ParserAstNode {
   final Token token;
 
-  ParenthesizedExpressionHandle(ParserAstType type, {required this.token})
+  ParenthesizedExpressionOrRecordLiteralBegin(ParserAstType type,
+      {required this.token})
+      : super("ParenthesizedExpressionOrRecordLiteral", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "token": token,
+      };
+}
+
+class RecordLiteralEnd extends ParserAstNode {
+  final Token token;
+  final int count;
+
+  RecordLiteralEnd(ParserAstType type,
+      {required this.token, required this.count})
+      : super("RecordLiteral", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "token": token,
+        "count": count,
+      };
+}
+
+class ParenthesizedExpressionEnd extends ParserAstNode {
+  final Token token;
+
+  ParenthesizedExpressionEnd(ParserAstType type, {required this.token})
       : super("ParenthesizedExpression", type);
 
   @override

pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_00.dart.expect

@@ -21,9 +21,10 @@ beginCompilationUnit(void)
       handleAsyncModifier(null, null)
       beginBlockFunctionBody({)
         handleNoTypeArguments([)
-        handleNoTypeArguments([)
-        handleLiteralList(0, [, null, ])
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleNoTypeArguments([)
+          handleLiteralList(0, [, null, ])
+        endParenthesizedExpression(()
         handleLiteralList(1, [, null, ])
         handleExpressionStatement(;)
       endBlockFunctionBody(1, {, })
@@ -41,13 +42,14 @@ beginCompilationUnit(void)
       handleAsyncModifier(null, null)
       beginBlockFunctionBody({)
         handleNoTypeArguments([)
-        handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ']'., Try inserting an identifier before ']'., {lexeme: ]}], ], ])
-        handleIdentifier(, expression)
-        handleNoTypeArguments(])
-        handleNoArguments(])
-        handleSend(, ])
-        handleRecoverableError(Message[ExpectedButGot, Expected ')' before this., null, {string: )}], ], ])
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ']'., Try inserting an identifier before ']'., {lexeme: ]}], ], ])
+          handleIdentifier(, expression)
+          handleNoTypeArguments(])
+          handleNoArguments(])
+          handleSend(, ])
+          handleRecoverableError(Message[ExpectedButGot, Expected ')' before this., null, {string: )}], ], ])
+        endParenthesizedExpression(()
         handleLiteralList(1, [, null, ])
         handleExpressionStatement(;)
       endBlockFunctionBody(1, {, })

pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_00.dart.intertwined.expect

@@ -42,19 +42,18 @@ parseUnit(void)
                                 parsePrecedenceExpression([, 1, true)
                                   parseUnaryExpression([, true)
                                     parsePrimary([, expression)
-                                      parseParenthesizedExpressionOrFunctionLiteral([)
-                                        parseParenthesizedExpression([)
-                                          parseExpressionInParenthesis([)
-                                            parseExpressionInParenthesisRest(()
-                                              parseExpression(()
-                                                parsePrecedenceExpression((, 1, true)
-                                                  parseUnaryExpression((, true)
-                                                    parsePrimary((, expression)
-                                                      listener: handleNoTypeArguments([)
-                                                      parseLiteralListSuffix((, null)
-                                                        listener: handleLiteralList(0, [, null, ])
-                                              ensureCloseParen(], ()
-                                          listener: handleParenthesizedExpression(()
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral([)
+                                        parseParenthesizedExpressionOrRecordLiteral([)
+                                          listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                          parseExpression(()
+                                            parsePrecedenceExpression((, 1, true)
+                                              parseUnaryExpression((, true)
+                                                parsePrimary((, expression)
+                                                  listener: handleNoTypeArguments([)
+                                                  parseLiteralListSuffix((, null)
+                                                    listener: handleLiteralList(0, [, null, ])
+                                          ensureCloseParen(], ()
+                                          listener: endParenthesizedExpression(()
                               listener: handleLiteralList(1, [, null, ])
                     ensureSemicolon(])
                     listener: handleExpressionStatement(;)
@@ -102,29 +101,28 @@ parseUnit(void)
                                 parsePrecedenceExpression([, 1, true)
                                   parseUnaryExpression([, true)
                                     parsePrimary([, expression)
-                                      parseParenthesizedExpressionOrFunctionLiteral([)
-                                        parseParenthesizedExpression([)
-                                          parseExpressionInParenthesis([)
-                                            parseExpressionInParenthesisRest(()
-                                              parseExpression(()
-                                                parsePrecedenceExpression((, 1, true)
-                                                  parseUnaryExpression((, true)
-                                                    parsePrimary((, expression)
-                                                      parseSend((, expression)
-                                                        isNextIdentifier(()
-                                                        ensureIdentifier((, expression)
-                                                          reportRecoverableErrorWithToken(], Instance of 'Template<(Token) => Message>')
-                                                            listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ']'., Try inserting an identifier before ']'., {lexeme: ]}], ], ])
-                                                          rewriter()
-                                                          listener: handleIdentifier(, expression)
-                                                        listener: handleNoTypeArguments(])
-                                                        parseArgumentsOpt()
-                                                          listener: handleNoArguments(])
-                                                        listener: handleSend(, ])
-                                              ensureCloseParen(, ()
-                                                reportRecoverableError(], Message[ExpectedButGot, Expected ')' before this., null, {string: )}])
-                                                  listener: handleRecoverableError(Message[ExpectedButGot, Expected ')' before this., null, {string: )}], ], ])
-                                          listener: handleParenthesizedExpression(()
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral([)
+                                        parseParenthesizedExpressionOrRecordLiteral([)
+                                          listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                          parseExpression(()
+                                            parsePrecedenceExpression((, 1, true)
+                                              parseUnaryExpression((, true)
+                                                parsePrimary((, expression)
+                                                  parseSend((, expression)
+                                                    isNextIdentifier(()
+                                                    ensureIdentifier((, expression)
+                                                      reportRecoverableErrorWithToken(], Instance of 'Template<(Token) => Message>')
+                                                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ']'., Try inserting an identifier before ']'., {lexeme: ]}], ], ])
+                                                      rewriter()
+                                                      listener: handleIdentifier(, expression)
+                                                    listener: handleNoTypeArguments(])
+                                                    parseArgumentsOpt()
+                                                      listener: handleNoArguments(])
+                                                    listener: handleSend(, ])
+                                          ensureCloseParen(, ()
+                                            reportRecoverableError(], Message[ExpectedButGot, Expected ')' before this., null, {string: )}])
+                                              listener: handleRecoverableError(Message[ExpectedButGot, Expected ')' before this., null, {string: )}], ], ])
+                                          listener: endParenthesizedExpression(()
                               listener: handleLiteralList(1, [, null, ])
                     ensureSemicolon(])
                     listener: handleExpressionStatement(;)

pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_04.dart.intertwined.expect

@@ -50,7 +50,7 @@ parseUnit(void)
                                       parsePrecedenceExpression((, 1, true)
                                         parseUnaryExpression((, true)
                                           parsePrimary((, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(()
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(()
                                                 listener: beginFunctionExpression(()

pkg/front_end/parser_testcases/error_recovery/extension_member_contributor_test_completion.dart.expect

@@ -187,16 +187,17 @@ beginCompilationUnit(extension)
           endInitializedIdentifier(print)
           handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], print, print)
         endVariablesDeclaration(1, ;)
-        handleIdentifier(l, expression)
-        handleNoTypeArguments(.)
-        handleNoArguments(.)
-        handleSend(l, .)
-        handleIdentifier(b, expressionContinuation)
-        handleNoTypeArguments())
-        handleNoArguments())
-        handleSend(b, ))
-        handleEndingBinaryExpression(.)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(l, expression)
+          handleNoTypeArguments(.)
+          handleNoArguments(.)
+          handleSend(l, .)
+          handleIdentifier(b, expressionContinuation)
+          handleNoTypeArguments())
+          handleNoArguments())
+          handleSend(b, ))
+          handleEndingBinaryExpression(.)
+        endParenthesizedExpression(()
         handleExpressionStatement(;)
       endBlockFunctionBody(2, {, })
     endTopLevelMethod(void, null, })

pkg/front_end/parser_testcases/error_recovery/extension_member_contributor_test_completion.dart.intertwined.expect

@@ -328,36 +328,35 @@ parseUnit(extension)
                       parsePrecedenceExpression(;, 1, true)
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(;)
-                              parseParenthesizedExpression(;)
-                                parseExpressionInParenthesis(;)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(l, expression)
-                                                listener: handleNoTypeArguments(.)
-                                                parseArgumentsOpt(l)
-                                                  listener: handleNoArguments(.)
-                                                listener: handleSend(l, .)
-                                        parsePrimary(., expressionContinuation)
-                                          parseSendOrFunctionLiteral(., expressionContinuation)
-                                            parseSend(., expressionContinuation)
-                                              isNextIdentifier(.)
-                                              ensureIdentifier(., expressionContinuation)
-                                                listener: handleIdentifier(b, expressionContinuation)
-                                              listener: handleNoTypeArguments())
-                                              parseArgumentsOpt(b)
-                                                listener: handleNoArguments())
-                                              listener: handleSend(b, ))
-                                        listener: handleEndingBinaryExpression(.)
-                                    ensureCloseParen(b, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                              parseParenthesizedExpressionOrRecordLiteral(;)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(l, expression)
+                                            listener: handleNoTypeArguments(.)
+                                            parseArgumentsOpt(l)
+                                              listener: handleNoArguments(.)
+                                            listener: handleSend(l, .)
+                                    parsePrimary(., expressionContinuation)
+                                      parseSendOrFunctionLiteral(., expressionContinuation)
+                                        parseSend(., expressionContinuation)
+                                          isNextIdentifier(.)
+                                          ensureIdentifier(., expressionContinuation)
+                                            listener: handleIdentifier(b, expressionContinuation)
+                                          listener: handleNoTypeArguments())
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments())
+                                          listener: handleSend(b, ))
+                                    listener: handleEndingBinaryExpression(.)
+                                ensureCloseParen(b, ()
+                                listener: endParenthesizedExpression(()
                     ensureSemicolon())
                     listener: handleExpressionStatement(;)
           notEofOrValue(}, })

pkg/front_end/parser_testcases/error_recovery/issue_42267.dart.intertwined.expect

@@ -99,7 +99,7 @@ parseUnit(void)
                                       parsePrecedenceExpression((, 1, true)
                                         parseUnaryExpression((, true)
                                           parsePrimary((, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(()
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(()
                                                 listener: beginFunctionExpression(()
@@ -250,7 +250,7 @@ parseUnit(void)
                                       parsePrecedenceExpression((, 1, true)
                                         parseUnaryExpression((, true)
                                           parsePrimary((, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(()
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(()
                                                 listener: beginFunctionExpression(()
@@ -403,7 +403,7 @@ parseUnit(void)
                                       parsePrecedenceExpression((, 1, true)
                                         parseUnaryExpression((, true)
                                           parsePrimary((, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(()
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(()
                                                 listener: beginFunctionExpression(()

pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.expect

@@ -832,14 +832,15 @@ beginCompilationUnit(class)
               handleRecoverableError(BreakOutsideOfLoop, break, break)
               handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], break, break)
               handleBreakStatement(false, break, ;)
-              handleIdentifier(x, expression)
-              handleNoTypeArguments(-)
-              handleNoArguments(-)
-              handleSend(x, -)
-              beginBinaryExpression(-)
-                handleLiteralInt(1)
-              endBinaryExpression(-)
-              handleParenthesizedExpression(()
+              beginParenthesizedExpressionOrRecordLiteral(()
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(-)
+                handleNoArguments(-)
+                handleSend(x, -)
+                beginBinaryExpression(-)
+                  handleLiteralInt(1)
+                endBinaryExpression(-)
+              endParenthesizedExpression(()
               beginBinaryExpression(+)
                 handleLiteralInt(1)
               endBinaryExpression(+)
@@ -1141,14 +1142,15 @@ beginCompilationUnit(class)
               handleRecoverableError(ContinueOutsideOfLoop, continue, continue)
               handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], continue, continue)
               handleContinueStatement(false, continue, ;)
-              handleIdentifier(x, expression)
-              handleNoTypeArguments(-)
-              handleNoArguments(-)
-              handleSend(x, -)
-              beginBinaryExpression(-)
-                handleLiteralInt(1)
-              endBinaryExpression(-)
-              handleParenthesizedExpression(()
+              beginParenthesizedExpressionOrRecordLiteral(()
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(-)
+                handleNoArguments(-)
+                handleSend(x, -)
+                beginBinaryExpression(-)
+                  handleLiteralInt(1)
+                endBinaryExpression(-)
+              endParenthesizedExpression(()
               beginBinaryExpression(+)
                 handleLiteralInt(1)
               endBinaryExpression(+)
@@ -1381,14 +1383,15 @@ beginCompilationUnit(class)
               endReturnStatement(true, return, ;)
               beginDoWhileStatement(do)
                 beginDoWhileStatementBody(()
-                  handleIdentifier(x, expression)
-                  handleNoTypeArguments(-)
-                  handleNoArguments(-)
-                  handleSend(x, -)
-                  beginBinaryExpression(-)
-                    handleLiteralInt(1)
-                  endBinaryExpression(-)
-                  handleParenthesizedExpression(()
+                  beginParenthesizedExpressionOrRecordLiteral(()
+                    handleIdentifier(x, expression)
+                    handleNoTypeArguments(-)
+                    handleNoArguments(-)
+                    handleSend(x, -)
+                    beginBinaryExpression(-)
+                      handleLiteralInt(1)
+                    endBinaryExpression(-)
+                  endParenthesizedExpression(()
                   beginBinaryExpression(+)
                     handleLiteralInt(1)
                   endBinaryExpression(+)
@@ -1520,14 +1523,15 @@ beginCompilationUnit(class)
               handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
               handleExpressionStatement(;)
               handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], else, else)
-              handleIdentifier(x, expression)
-              handleNoTypeArguments(-)
-              handleNoArguments(-)
-              handleSend(x, -)
-              beginBinaryExpression(-)
-                handleLiteralInt(1)
-              endBinaryExpression(-)
-              handleParenthesizedExpression(()
+              beginParenthesizedExpressionOrRecordLiteral(()
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(-)
+                handleNoArguments(-)
+                handleSend(x, -)
+                beginBinaryExpression(-)
+                  handleLiteralInt(1)
+                endBinaryExpression(-)
+              endParenthesizedExpression(()
               beginBinaryExpression(+)
                 handleLiteralInt(1)
               endBinaryExpression(+)
@@ -2764,14 +2768,15 @@ beginCompilationUnit(class)
                 handleIsOperator(is, null)
                 handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], is, is)
               endReturnStatement(true, return, ;)
-              handleIdentifier(x, expression)
-              handleNoTypeArguments(-)
-              handleNoArguments(-)
-              handleSend(x, -)
-              beginBinaryExpression(-)
-                handleLiteralInt(1)
-              endBinaryExpression(-)
-              handleParenthesizedExpression(()
+              beginParenthesizedExpressionOrRecordLiteral(()
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(-)
+                handleNoArguments(-)
+                handleSend(x, -)
+                beginBinaryExpression(-)
+                  handleLiteralInt(1)
+                endBinaryExpression(-)
+              endParenthesizedExpression(()
               beginBinaryExpression(+)
                 handleLiteralInt(1)
               endBinaryExpression(+)
@@ -3641,14 +3646,15 @@ beginCompilationUnit(class)
               endIfStatement(if, null)
               beginReturnStatement(return)
                 handleRecoverableError(Message[UnexpectedToken, Unexpected token 'return'., null, {lexeme: return}], return, return)
-                handleIdentifier(x, expression)
-                handleNoTypeArguments(-)
-                handleNoArguments(-)
-                handleSend(x, -)
-                beginBinaryExpression(-)
-                  handleLiteralInt(1)
-                endBinaryExpression(-)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(x, expression)
+                  handleNoTypeArguments(-)
+                  handleNoArguments(-)
+                  handleSend(x, -)
+                  beginBinaryExpression(-)
+                    handleLiteralInt(1)
+                  endBinaryExpression(-)
+                endParenthesizedExpression(()
                 beginBinaryExpression(+)
                   handleLiteralInt(1)
                 endBinaryExpression(+)
@@ -4198,14 +4204,15 @@ beginCompilationUnit(class)
                 endThenStatement(;)
               endIfStatement(if, null)
               beginReturnStatement(return)
-                handleIdentifier(x, expression)
-                handleNoTypeArguments(-)
-                handleNoArguments(-)
-                handleSend(x, -)
-                beginBinaryExpression(-)
-                  handleLiteralInt(1)
-                endBinaryExpression(-)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(x, expression)
+                  handleNoTypeArguments(-)
+                  handleNoArguments(-)
+                  handleSend(x, -)
+                  beginBinaryExpression(-)
+                    handleLiteralInt(1)
+                  endBinaryExpression(-)
+                endParenthesizedExpression(()
                 beginBinaryExpression(+)
                   handleLiteralInt(1)
                 endBinaryExpression(+)
@@ -4326,14 +4333,15 @@ beginCompilationUnit(class)
                 endBlock(0, {, }, BlockKind(try statement))
                 handleRecoverableError(OnlyTry, try, try)
               endTryStatement(0, try, null)
-              handleIdentifier(x, expression)
-              handleNoTypeArguments(-)
-              handleNoArguments(-)
-              handleSend(x, -)
-              beginBinaryExpression(-)
-                handleLiteralInt(1)
-              endBinaryExpression(-)
-              handleParenthesizedExpression(()
+              beginParenthesizedExpressionOrRecordLiteral(()
+                handleIdentifier(x, expression)
+                handleNoTypeArguments(-)
+                handleNoArguments(-)
+                handleSend(x, -)
+                beginBinaryExpression(-)
+                  handleLiteralInt(1)
+                endBinaryExpression(-)
+              endParenthesizedExpression(()
               beginBinaryExpression(+)
                 handleLiteralInt(1)
               endBinaryExpression(+)

pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.intertwined.expect

@@ -883,32 +883,31 @@ parseUnit(class)
                               parsePrecedenceExpression(;, 1, true)
                                 parseUnaryExpression(;, true)
                                   parsePrimary(;, expression)
-                                    parseParenthesizedExpressionOrFunctionLiteral(;)
-                                      parseParenthesizedExpression(;)
-                                        parseExpressionInParenthesis(;)
-                                          parseExpressionInParenthesisRest(()
-                                            parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
-                                                    parseSendOrFunctionLiteral((, expression)
-                                                      parseSend((, expression)
-                                                        isNextIdentifier(()
-                                                        ensureIdentifier((, expression)
-                                                          listener: handleIdentifier(x, expression)
-                                                        listener: handleNoTypeArguments(-)
-                                                        parseArgumentsOpt(x)
-                                                          listener: handleNoArguments(-)
-                                                        listener: handleSend(x, -)
-                                                listener: beginBinaryExpression(-)
-                                                parsePrecedenceExpression(-, 14, true)
-                                                  parseUnaryExpression(-, true)
-                                                    parsePrimary(-, expression)
-                                                      parseLiteralInt(-)
-                                                        listener: handleLiteralInt(1)
-                                                listener: endBinaryExpression(-)
-                                            ensureCloseParen(1, ()
-                                        listener: handleParenthesizedExpression(()
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                                      parseParenthesizedExpressionOrRecordLiteral(;)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        parseExpression(()
+                                          parsePrecedenceExpression((, 1, true)
+                                            parseUnaryExpression((, true)
+                                              parsePrimary((, expression)
+                                                parseSendOrFunctionLiteral((, expression)
+                                                  parseSend((, expression)
+                                                    isNextIdentifier(()
+                                                    ensureIdentifier((, expression)
+                                                      listener: handleIdentifier(x, expression)
+                                                    listener: handleNoTypeArguments(-)
+                                                    parseArgumentsOpt(x)
+                                                      listener: handleNoArguments(-)
+                                                    listener: handleSend(x, -)
+                                            listener: beginBinaryExpression(-)
+                                            parsePrecedenceExpression(-, 14, true)
+                                              parseUnaryExpression(-, true)
+                                                parsePrimary(-, expression)
+                                                  parseLiteralInt(-)
+                                                    listener: handleLiteralInt(1)
+                                            listener: endBinaryExpression(-)
+                                        ensureCloseParen(1, ()
+                                        listener: endParenthesizedExpression(()
                                 listener: beginBinaryExpression(+)
                                 parsePrecedenceExpression(+, 14, true)
                                   parseUnaryExpression(+, true)
@@ -1655,32 +1654,31 @@ parseUnit(class)
                               parsePrecedenceExpression(;, 1, true)
                                 parseUnaryExpression(;, true)
                                   parsePrimary(;, expression)
-                                    parseParenthesizedExpressionOrFunctionLiteral(;)
-                                      parseParenthesizedExpression(;)
-                                        parseExpressionInParenthesis(;)
-                                          parseExpressionInParenthesisRest(()
-                                            parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
-                                                    parseSendOrFunctionLiteral((, expression)
-                                                      parseSend((, expression)
-                                                        isNextIdentifier(()
-                                                        ensureIdentifier((, expression)
-                                                          listener: handleIdentifier(x, expression)
-                                                        listener: handleNoTypeArguments(-)
-                                                        parseArgumentsOpt(x)
-                                                          listener: handleNoArguments(-)
-                                                        listener: handleSend(x, -)
-                                                listener: beginBinaryExpression(-)
-                                                parsePrecedenceExpression(-, 14, true)
-                                                  parseUnaryExpression(-, true)
-                                                    parsePrimary(-, expression)
-                                                      parseLiteralInt(-)
-                                                        listener: handleLiteralInt(1)
-                                                listener: endBinaryExpression(-)
-                                            ensureCloseParen(1, ()
-                                        listener: handleParenthesizedExpression(()
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                                      parseParenthesizedExpressionOrRecordLiteral(;)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        parseExpression(()
+                                          parsePrecedenceExpression((, 1, true)
+                                            parseUnaryExpression((, true)
+                                              parsePrimary((, expression)
+                                                parseSendOrFunctionLiteral((, expression)
+                                                  parseSend((, expression)
+                                                    isNextIdentifier(()
+                                                    ensureIdentifier((, expression)
+                                                      listener: handleIdentifier(x, expression)
+                                                    listener: handleNoTypeArguments(-)
+                                                    parseArgumentsOpt(x)
+                                                      listener: handleNoArguments(-)
+                                                    listener: handleSend(x, -)
+                                            listener: beginBinaryExpression(-)
+                                            parsePrecedenceExpression(-, 14, true)
+                                              parseUnaryExpression(-, true)
+                                                parsePrimary(-, expression)
+                                                  parseLiteralInt(-)
+                                                    listener: handleLiteralInt(1)
+                                            listener: endBinaryExpression(-)
+                                        ensureCloseParen(1, ()
+                                        listener: endParenthesizedExpression(()
                                 listener: beginBinaryExpression(+)
                                 parsePrecedenceExpression(+, 14, true)
                                   parseUnaryExpression(+, true)
@@ -2262,32 +2260,31 @@ parseUnit(class)
                                     parsePrecedenceExpression(do, 1, true)
                                       parseUnaryExpression(do, true)
                                         parsePrimary(do, expression)
-                                          parseParenthesizedExpressionOrFunctionLiteral(do)
-                                            parseParenthesizedExpression(do)
-                                              parseExpressionInParenthesis(do)
-                                                parseExpressionInParenthesisRest(()
-                                                  parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
-                                                          parseSendOrFunctionLiteral((, expression)
-                                                            parseSend((, expression)
-                                                              isNextIdentifier(()
-                                                              ensureIdentifier((, expression)
-                                                                listener: handleIdentifier(x, expression)
-                                                              listener: handleNoTypeArguments(-)
-                                                              parseArgumentsOpt(x)
-                                                                listener: handleNoArguments(-)
-                                                              listener: handleSend(x, -)
-                                                      listener: beginBinaryExpression(-)
-                                                      parsePrecedenceExpression(-, 14, true)
-                                                        parseUnaryExpression(-, true)
-                                                          parsePrimary(-, expression)
-                                                            parseLiteralInt(-)
-                                                              listener: handleLiteralInt(1)
-                                                      listener: endBinaryExpression(-)
-                                                  ensureCloseParen(1, ()
-                                              listener: handleParenthesizedExpression(()
+                                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(do)
+                                            parseParenthesizedExpressionOrRecordLiteral(do)
+                                              listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                              parseExpression(()
+                                                parsePrecedenceExpression((, 1, true)
+                                                  parseUnaryExpression((, true)
+                                                    parsePrimary((, expression)
+                                                      parseSendOrFunctionLiteral((, expression)
+                                                        parseSend((, expression)
+                                                          isNextIdentifier(()
+                                                          ensureIdentifier((, expression)
+                                                            listener: handleIdentifier(x, expression)
+                                                          listener: handleNoTypeArguments(-)
+                                                          parseArgumentsOpt(x)
+                                                            listener: handleNoArguments(-)
+                                                          listener: handleSend(x, -)
+                                                  listener: beginBinaryExpression(-)
+                                                  parsePrecedenceExpression(-, 14, true)
+                                                    parseUnaryExpression(-, true)
+                                                      parsePrimary(-, expression)
+                                                        parseLiteralInt(-)
+                                                          listener: handleLiteralInt(1)
+                                                  listener: endBinaryExpression(-)
+                                              ensureCloseParen(1, ()
+                                              listener: endParenthesizedExpression(()
                                       listener: beginBinaryExpression(+)
                                       parsePrecedenceExpression(+, 14, true)
                                         parseUnaryExpression(+, true)
@@ -2634,32 +2631,31 @@ parseUnit(class)
                               parsePrecedenceExpression(else, 1, true)
                                 parseUnaryExpression(else, true)
                                   parsePrimary(else, expression)
-                                    parseParenthesizedExpressionOrFunctionLiteral(else)
-                                      parseParenthesizedExpression(else)
-                                        parseExpressionInParenthesis(else)
-                                          parseExpressionInParenthesisRest(()
-                                            parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
-                                                    parseSendOrFunctionLiteral((, expression)
-                                                      parseSend((, expression)
-                                                        isNextIdentifier(()
-                                                        ensureIdentifier((, expression)
-                                                          listener: handleIdentifier(x, expression)
-                                                        listener: handleNoTypeArguments(-)
-                                                        parseArgumentsOpt(x)
-                                                          listener: handleNoArguments(-)
-                                                        listener: handleSend(x, -)
-                                                listener: beginBinaryExpression(-)
-                                                parsePrecedenceExpression(-, 14, true)
-                                                  parseUnaryExpression(-, true)
-                                                    parsePrimary(-, expression)
-                                                      parseLiteralInt(-)
-                                                        listener: handleLiteralInt(1)
-                                                listener: endBinaryExpression(-)
-                                            ensureCloseParen(1, ()
-                                        listener: handleParenthesizedExpression(()
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(else)
+                                      parseParenthesizedExpressionOrRecordLiteral(else)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        parseExpression(()
+                                          parsePrecedenceExpression((, 1, true)
+                                            parseUnaryExpression((, true)
+                                              parsePrimary((, expression)
+                                                parseSendOrFunctionLiteral((, expression)
+                                                  parseSend((, expression)
+                                                    isNextIdentifier(()
+                                                    ensureIdentifier((, expression)
+                                                      listener: handleIdentifier(x, expression)
+                                                    listener: handleNoTypeArguments(-)
+                                                    parseArgumentsOpt(x)
+                                                      listener: handleNoArguments(-)
+                                                    listener: handleSend(x, -)
+                                            listener: beginBinaryExpression(-)
+                                            parsePrecedenceExpression(-, 14, true)
+                                              parseUnaryExpression(-, true)
+                                                parsePrimary(-, expression)
+                                                  parseLiteralInt(-)
+                                                    listener: handleLiteralInt(1)
+                                            listener: endBinaryExpression(-)
+                                        ensureCloseParen(1, ()
+                                        listener: endParenthesizedExpression(()
                                 listener: beginBinaryExpression(+)
                                 parsePrecedenceExpression(+, 14, true)
                                   parseUnaryExpression(+, true)
@@ -5766,32 +5762,31 @@ parseUnit(class)
                               parsePrecedenceExpression(;, 1, true)
                                 parseUnaryExpression(;, true)
                                   parsePrimary(;, expression)
-                                    parseParenthesizedExpressionOrFunctionLiteral(;)
-                                      parseParenthesizedExpression(;)
-                                        parseExpressionInParenthesis(;)
-                                          parseExpressionInParenthesisRest(()
-                                            parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
-                                                    parseSendOrFunctionLiteral((, expression)
-                                                      parseSend((, expression)
-                                                        isNextIdentifier(()
-                                                        ensureIdentifier((, expression)
-                                                          listener: handleIdentifier(x, expression)
-                                                        listener: handleNoTypeArguments(-)
-                                                        parseArgumentsOpt(x)
-                                                          listener: handleNoArguments(-)
-                                                        listener: handleSend(x, -)
-                                                listener: beginBinaryExpression(-)
-                                                parsePrecedenceExpression(-, 14, true)
-                                                  parseUnaryExpression(-, true)
-                                                    parsePrimary(-, expression)
-                                                      parseLiteralInt(-)
-                                                        listener: handleLiteralInt(1)
-                                                listener: endBinaryExpression(-)
-                                            ensureCloseParen(1, ()
-                                        listener: handleParenthesizedExpression(()
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                                      parseParenthesizedExpressionOrRecordLiteral(;)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        parseExpression(()
+                                          parsePrecedenceExpression((, 1, true)
+                                            parseUnaryExpression((, true)
+                                              parsePrimary((, expression)
+                                                parseSendOrFunctionLiteral((, expression)
+                                                  parseSend((, expression)
+                                                    isNextIdentifier(()
+                                                    ensureIdentifier((, expression)
+                                                      listener: handleIdentifier(x, expression)
+                                                    listener: handleNoTypeArguments(-)
+                                                    parseArgumentsOpt(x)
+                                                      listener: handleNoArguments(-)
+                                                    listener: handleSend(x, -)
+                                            listener: beginBinaryExpression(-)
+                                            parsePrecedenceExpression(-, 14, true)
+                                              parseUnaryExpression(-, true)
+                                                parsePrimary(-, expression)
+                                                  parseLiteralInt(-)
+                                                    listener: handleLiteralInt(1)
+                                            listener: endBinaryExpression(-)
+                                        ensureCloseParen(1, ()
+                                        listener: endParenthesizedExpression(()
                                 listener: beginBinaryExpression(+)
                                 parsePrecedenceExpression(+, 14, true)
                                   parseUnaryExpression(+, true)
@@ -7936,32 +7931,31 @@ parseUnit(class)
                                 reportRecoverableErrorWithToken(return, Instance of 'Template<(Token) => Message>')
                                   listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'return'., null, {lexeme: return}], return, return)
                                 parsePrimary(return, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(return)
-                                    parseParenthesizedExpression(return)
-                                      parseExpressionInParenthesis(return)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(x, expression)
-                                                      listener: handleNoTypeArguments(-)
-                                                      parseArgumentsOpt(x)
-                                                        listener: handleNoArguments(-)
-                                                      listener: handleSend(x, -)
-                                              listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
-                                                    parseLiteralInt(-)
-                                                      listener: handleLiteralInt(1)
-                                              listener: endBinaryExpression(-)
-                                          ensureCloseParen(1, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
+                                    parseParenthesizedExpressionOrRecordLiteral(return)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(x, expression)
+                                                  listener: handleNoTypeArguments(-)
+                                                  parseArgumentsOpt(x)
+                                                    listener: handleNoArguments(-)
+                                                  listener: handleSend(x, -)
+                                          listener: beginBinaryExpression(-)
+                                          parsePrecedenceExpression(-, 14, true)
+                                            parseUnaryExpression(-, true)
+                                              parsePrimary(-, expression)
+                                                parseLiteralInt(-)
+                                                  listener: handleLiteralInt(1)
+                                          listener: endBinaryExpression(-)
+                                      ensureCloseParen(1, ()
+                                      listener: endParenthesizedExpression(()
                             listener: beginBinaryExpression(+)
                             parsePrecedenceExpression(+, 14, true)
                               parseUnaryExpression(+, true)
@@ -9320,32 +9314,31 @@ parseUnit(class)
                               parsePrecedenceExpression(throw, 1, true)
                                 parseUnaryExpression(throw, true)
                                   parsePrimary(throw, expression)
-                                    parseParenthesizedExpressionOrFunctionLiteral(throw)
-                                      parseParenthesizedExpression(throw)
-                                        parseExpressionInParenthesis(throw)
-                                          parseExpressionInParenthesisRest(()
-                                            parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
-                                                    parseSendOrFunctionLiteral((, expression)
-                                                      parseSend((, expression)
-                                                        isNextIdentifier(()
-                                                        ensureIdentifier((, expression)
-                                                          listener: handleIdentifier(x, expression)
-                                                        listener: handleNoTypeArguments(-)
-                                                        parseArgumentsOpt(x)
-                                                          listener: handleNoArguments(-)
-                                                        listener: handleSend(x, -)
-                                                listener: beginBinaryExpression(-)
-                                                parsePrecedenceExpression(-, 14, true)
-                                                  parseUnaryExpression(-, true)
-                                                    parsePrimary(-, expression)
-                                                      parseLiteralInt(-)
-                                                        listener: handleLiteralInt(1)
-                                                listener: endBinaryExpression(-)
-                                            ensureCloseParen(1, ()
-                                        listener: handleParenthesizedExpression(()
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(throw)
+                                      parseParenthesizedExpressionOrRecordLiteral(throw)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        parseExpression(()
+                                          parsePrecedenceExpression((, 1, true)
+                                            parseUnaryExpression((, true)
+                                              parsePrimary((, expression)
+                                                parseSendOrFunctionLiteral((, expression)
+                                                  parseSend((, expression)
+                                                    isNextIdentifier(()
+                                                    ensureIdentifier((, expression)
+                                                      listener: handleIdentifier(x, expression)
+                                                    listener: handleNoTypeArguments(-)
+                                                    parseArgumentsOpt(x)
+                                                      listener: handleNoArguments(-)
+                                                    listener: handleSend(x, -)
+                                            listener: beginBinaryExpression(-)
+                                            parsePrecedenceExpression(-, 14, true)
+                                              parseUnaryExpression(-, true)
+                                                parsePrimary(-, expression)
+                                                  parseLiteralInt(-)
+                                                    listener: handleLiteralInt(1)
+                                            listener: endBinaryExpression(-)
+                                        ensureCloseParen(1, ()
+                                        listener: endParenthesizedExpression(()
                                 listener: beginBinaryExpression(+)
                                 parsePrecedenceExpression(+, 14, true)
                                   parseUnaryExpression(+, true)
@@ -9649,32 +9642,31 @@ parseUnit(class)
                               parsePrecedenceExpression(}, 1, true)
                                 parseUnaryExpression(}, true)
                                   parsePrimary(}, expression)
-                                    parseParenthesizedExpressionOrFunctionLiteral(})
-                                      parseParenthesizedExpression(})
-                                        parseExpressionInParenthesis(})
-                                          parseExpressionInParenthesisRest(()
-                                            parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
-                                                    parseSendOrFunctionLiteral((, expression)
-                                                      parseSend((, expression)
-                                                        isNextIdentifier(()
-                                                        ensureIdentifier((, expression)
-                                                          listener: handleIdentifier(x, expression)
-                                                        listener: handleNoTypeArguments(-)
-                                                        parseArgumentsOpt(x)
-                                                          listener: handleNoArguments(-)
-                                                        listener: handleSend(x, -)
-                                                listener: beginBinaryExpression(-)
-                                                parsePrecedenceExpression(-, 14, true)
-                                                  parseUnaryExpression(-, true)
-                                                    parsePrimary(-, expression)
-                                                      parseLiteralInt(-)
-                                                        listener: handleLiteralInt(1)
-                                                listener: endBinaryExpression(-)
-                                            ensureCloseParen(1, ()
-                                        listener: handleParenthesizedExpression(()
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(})
+                                      parseParenthesizedExpressionOrRecordLiteral(})
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        parseExpression(()
+                                          parsePrecedenceExpression((, 1, true)
+                                            parseUnaryExpression((, true)
+                                              parsePrimary((, expression)
+                                                parseSendOrFunctionLiteral((, expression)
+                                                  parseSend((, expression)
+                                                    isNextIdentifier(()
+                                                    ensureIdentifier((, expression)
+                                                      listener: handleIdentifier(x, expression)
+                                                    listener: handleNoTypeArguments(-)
+                                                    parseArgumentsOpt(x)
+                                                      listener: handleNoArguments(-)
+                                                    listener: handleSend(x, -)
+                                            listener: beginBinaryExpression(-)
+                                            parsePrecedenceExpression(-, 14, true)
+                                              parseUnaryExpression(-, true)
+                                                parsePrimary(-, expression)
+                                                  parseLiteralInt(-)
+                                                    listener: handleLiteralInt(1)
+                                            listener: endBinaryExpression(-)
+                                        ensureCloseParen(1, ()
+                                        listener: endParenthesizedExpression(()
                                 listener: beginBinaryExpression(+)
                                 parsePrecedenceExpression(+, 14, true)
                                   parseUnaryExpression(+, true)

pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.expect

@@ -798,14 +798,15 @@ beginCompilationUnit(int)
         handleRecoverableError(BreakOutsideOfLoop, break, break)
         handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], break, break)
         handleBreakStatement(false, break, ;)
-        handleIdentifier(x, expression)
-        handleNoTypeArguments(-)
-        handleNoArguments(-)
-        handleSend(x, -)
-        beginBinaryExpression(-)
-          handleLiteralInt(1)
-        endBinaryExpression(-)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(x, expression)
+          handleNoTypeArguments(-)
+          handleNoArguments(-)
+          handleSend(x, -)
+          beginBinaryExpression(-)
+            handleLiteralInt(1)
+          endBinaryExpression(-)
+        endParenthesizedExpression(()
         beginBinaryExpression(+)
           handleLiteralInt(1)
         endBinaryExpression(+)
@@ -1102,14 +1103,15 @@ beginCompilationUnit(int)
         handleRecoverableError(ContinueOutsideOfLoop, continue, continue)
         handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], continue, continue)
         handleContinueStatement(false, continue, ;)
-        handleIdentifier(x, expression)
-        handleNoTypeArguments(-)
-        handleNoArguments(-)
-        handleSend(x, -)
-        beginBinaryExpression(-)
-          handleLiteralInt(1)
-        endBinaryExpression(-)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(x, expression)
+          handleNoTypeArguments(-)
+          handleNoArguments(-)
+          handleSend(x, -)
+          beginBinaryExpression(-)
+            handleLiteralInt(1)
+          endBinaryExpression(-)
+        endParenthesizedExpression(()
         beginBinaryExpression(+)
           handleLiteralInt(1)
         endBinaryExpression(+)
@@ -1338,14 +1340,15 @@ beginCompilationUnit(int)
         endReturnStatement(true, return, ;)
         beginDoWhileStatement(do)
           beginDoWhileStatementBody(()
-            handleIdentifier(x, expression)
-            handleNoTypeArguments(-)
-            handleNoArguments(-)
-            handleSend(x, -)
-            beginBinaryExpression(-)
-              handleLiteralInt(1)
-            endBinaryExpression(-)
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleIdentifier(x, expression)
+              handleNoTypeArguments(-)
+              handleNoArguments(-)
+              handleSend(x, -)
+              beginBinaryExpression(-)
+                handleLiteralInt(1)
+              endBinaryExpression(-)
+            endParenthesizedExpression(()
             beginBinaryExpression(+)
               handleLiteralInt(1)
             endBinaryExpression(+)
@@ -1475,14 +1478,15 @@ beginCompilationUnit(int)
         handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return)
         handleExpressionStatement(;)
         handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], else, else)
-        handleIdentifier(x, expression)
-        handleNoTypeArguments(-)
-        handleNoArguments(-)
-        handleSend(x, -)
-        beginBinaryExpression(-)
-          handleLiteralInt(1)
-        endBinaryExpression(-)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(x, expression)
+          handleNoTypeArguments(-)
+          handleNoArguments(-)
+          handleSend(x, -)
+          beginBinaryExpression(-)
+            handleLiteralInt(1)
+          endBinaryExpression(-)
+        endParenthesizedExpression(()
         beginBinaryExpression(+)
           handleLiteralInt(1)
         endBinaryExpression(+)
@@ -2699,14 +2703,15 @@ beginCompilationUnit(int)
           handleIsOperator(is, null)
           handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], is, is)
         endReturnStatement(true, return, ;)
-        handleIdentifier(x, expression)
-        handleNoTypeArguments(-)
-        handleNoArguments(-)
-        handleSend(x, -)
-        beginBinaryExpression(-)
-          handleLiteralInt(1)
-        endBinaryExpression(-)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(x, expression)
+          handleNoTypeArguments(-)
+          handleNoArguments(-)
+          handleSend(x, -)
+          beginBinaryExpression(-)
+            handleLiteralInt(1)
+          endBinaryExpression(-)
+        endParenthesizedExpression(()
         beginBinaryExpression(+)
           handleLiteralInt(1)
         endBinaryExpression(+)
@@ -3561,14 +3566,15 @@ beginCompilationUnit(int)
         endIfStatement(if, null)
         beginReturnStatement(return)
           handleRecoverableError(Message[UnexpectedToken, Unexpected token 'return'., null, {lexeme: return}], return, return)
-          handleIdentifier(x, expression)
-          handleNoTypeArguments(-)
-          handleNoArguments(-)
-          handleSend(x, -)
-          beginBinaryExpression(-)
-            handleLiteralInt(1)
-          endBinaryExpression(-)
-          handleParenthesizedExpression(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleIdentifier(x, expression)
+            handleNoTypeArguments(-)
+            handleNoArguments(-)
+            handleSend(x, -)
+            beginBinaryExpression(-)
+              handleLiteralInt(1)
+            endBinaryExpression(-)
+          endParenthesizedExpression(()
           beginBinaryExpression(+)
             handleLiteralInt(1)
           endBinaryExpression(+)
@@ -4087,14 +4093,15 @@ beginCompilationUnit(int)
           endThenStatement(;)
         endIfStatement(if, null)
         beginReturnStatement(return)
-          handleIdentifier(x, expression)
-          handleNoTypeArguments(-)
-          handleNoArguments(-)
-          handleSend(x, -)
-          beginBinaryExpression(-)
-            handleLiteralInt(1)
-          endBinaryExpression(-)
-          handleParenthesizedExpression(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleIdentifier(x, expression)
+            handleNoTypeArguments(-)
+            handleNoArguments(-)
+            handleSend(x, -)
+            beginBinaryExpression(-)
+              handleLiteralInt(1)
+            endBinaryExpression(-)
+          endParenthesizedExpression(()
           beginBinaryExpression(+)
             handleLiteralInt(1)
           endBinaryExpression(+)
@@ -4213,14 +4220,15 @@ beginCompilationUnit(int)
           endBlock(0, {, }, BlockKind(try statement))
           handleRecoverableError(OnlyTry, try, try)
         endTryStatement(0, try, null)
-        handleIdentifier(x, expression)
-        handleNoTypeArguments(-)
-        handleNoArguments(-)
-        handleSend(x, -)
-        beginBinaryExpression(-)
-          handleLiteralInt(1)
-        endBinaryExpression(-)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(x, expression)
+          handleNoTypeArguments(-)
+          handleNoArguments(-)
+          handleSend(x, -)
+          beginBinaryExpression(-)
+            handleLiteralInt(1)
+          endBinaryExpression(-)
+        endParenthesizedExpression(()
         beginBinaryExpression(+)
           handleLiteralInt(1)
         endBinaryExpression(+)

pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.intertwined.expect

@@ -836,32 +836,31 @@ parseUnit(int)
                       parsePrecedenceExpression(;, 1, true)
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(;)
-                              parseParenthesizedExpression(;)
-                                parseExpressionInParenthesis(;)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(x, expression)
-                                                listener: handleNoTypeArguments(-)
-                                                parseArgumentsOpt(x)
-                                                  listener: handleNoArguments(-)
-                                                listener: handleSend(x, -)
-                                        listener: beginBinaryExpression(-)
-                                        parsePrecedenceExpression(-, 14, true)
-                                          parseUnaryExpression(-, true)
-                                            parsePrimary(-, expression)
-                                              parseLiteralInt(-)
-                                                listener: handleLiteralInt(1)
-                                        listener: endBinaryExpression(-)
-                                    ensureCloseParen(1, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                              parseParenthesizedExpressionOrRecordLiteral(;)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(x, expression)
+                                            listener: handleNoTypeArguments(-)
+                                            parseArgumentsOpt(x)
+                                              listener: handleNoArguments(-)
+                                            listener: handleSend(x, -)
+                                    listener: beginBinaryExpression(-)
+                                    parsePrecedenceExpression(-, 14, true)
+                                      parseUnaryExpression(-, true)
+                                        parsePrimary(-, expression)
+                                          parseLiteralInt(-)
+                                            listener: handleLiteralInt(1)
+                                    listener: endBinaryExpression(-)
+                                ensureCloseParen(1, ()
+                                listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(+)
                         parsePrecedenceExpression(+, 14, true)
                           parseUnaryExpression(+, true)
@@ -1588,32 +1587,31 @@ parseUnit(int)
                       parsePrecedenceExpression(;, 1, true)
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(;)
-                              parseParenthesizedExpression(;)
-                                parseExpressionInParenthesis(;)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(x, expression)
-                                                listener: handleNoTypeArguments(-)
-                                                parseArgumentsOpt(x)
-                                                  listener: handleNoArguments(-)
-                                                listener: handleSend(x, -)
-                                        listener: beginBinaryExpression(-)
-                                        parsePrecedenceExpression(-, 14, true)
-                                          parseUnaryExpression(-, true)
-                                            parsePrimary(-, expression)
-                                              parseLiteralInt(-)
-                                                listener: handleLiteralInt(1)
-                                        listener: endBinaryExpression(-)
-                                    ensureCloseParen(1, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                              parseParenthesizedExpressionOrRecordLiteral(;)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(x, expression)
+                                            listener: handleNoTypeArguments(-)
+                                            parseArgumentsOpt(x)
+                                              listener: handleNoArguments(-)
+                                            listener: handleSend(x, -)
+                                    listener: beginBinaryExpression(-)
+                                    parsePrecedenceExpression(-, 14, true)
+                                      parseUnaryExpression(-, true)
+                                        parsePrimary(-, expression)
+                                          parseLiteralInt(-)
+                                            listener: handleLiteralInt(1)
+                                    listener: endBinaryExpression(-)
+                                ensureCloseParen(1, ()
+                                listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(+)
                         parsePrecedenceExpression(+, 14, true)
                           parseUnaryExpression(+, true)
@@ -2179,32 +2177,31 @@ parseUnit(int)
                             parsePrecedenceExpression(do, 1, true)
                               parseUnaryExpression(do, true)
                                 parsePrimary(do, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(do)
-                                    parseParenthesizedExpression(do)
-                                      parseExpressionInParenthesis(do)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(x, expression)
-                                                      listener: handleNoTypeArguments(-)
-                                                      parseArgumentsOpt(x)
-                                                        listener: handleNoArguments(-)
-                                                      listener: handleSend(x, -)
-                                              listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
-                                                    parseLiteralInt(-)
-                                                      listener: handleLiteralInt(1)
-                                              listener: endBinaryExpression(-)
-                                          ensureCloseParen(1, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(do)
+                                    parseParenthesizedExpressionOrRecordLiteral(do)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(x, expression)
+                                                  listener: handleNoTypeArguments(-)
+                                                  parseArgumentsOpt(x)
+                                                    listener: handleNoArguments(-)
+                                                  listener: handleSend(x, -)
+                                          listener: beginBinaryExpression(-)
+                                          parsePrecedenceExpression(-, 14, true)
+                                            parseUnaryExpression(-, true)
+                                              parsePrimary(-, expression)
+                                                parseLiteralInt(-)
+                                                  listener: handleLiteralInt(1)
+                                          listener: endBinaryExpression(-)
+                                      ensureCloseParen(1, ()
+                                      listener: endParenthesizedExpression(()
                               listener: beginBinaryExpression(+)
                               parsePrecedenceExpression(+, 14, true)
                                 parseUnaryExpression(+, true)
@@ -2543,32 +2540,31 @@ parseUnit(int)
                       parsePrecedenceExpression(else, 1, true)
                         parseUnaryExpression(else, true)
                           parsePrimary(else, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(else)
-                              parseParenthesizedExpression(else)
-                                parseExpressionInParenthesis(else)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(x, expression)
-                                                listener: handleNoTypeArguments(-)
-                                                parseArgumentsOpt(x)
-                                                  listener: handleNoArguments(-)
-                                                listener: handleSend(x, -)
-                                        listener: beginBinaryExpression(-)
-                                        parsePrecedenceExpression(-, 14, true)
-                                          parseUnaryExpression(-, true)
-                                            parsePrimary(-, expression)
-                                              parseLiteralInt(-)
-                                                listener: handleLiteralInt(1)
-                                        listener: endBinaryExpression(-)
-                                    ensureCloseParen(1, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(else)
+                              parseParenthesizedExpressionOrRecordLiteral(else)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(x, expression)
+                                            listener: handleNoTypeArguments(-)
+                                            parseArgumentsOpt(x)
+                                              listener: handleNoArguments(-)
+                                            listener: handleSend(x, -)
+                                    listener: beginBinaryExpression(-)
+                                    parsePrecedenceExpression(-, 14, true)
+                                      parseUnaryExpression(-, true)
+                                        parsePrimary(-, expression)
+                                          parseLiteralInt(-)
+                                            listener: handleLiteralInt(1)
+                                    listener: endBinaryExpression(-)
+                                ensureCloseParen(1, ()
+                                listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(+)
                         parsePrecedenceExpression(+, 14, true)
                           parseUnaryExpression(+, true)
@@ -5594,32 +5590,31 @@ parseUnit(int)
                       parsePrecedenceExpression(;, 1, true)
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(;)
-                              parseParenthesizedExpression(;)
-                                parseExpressionInParenthesis(;)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(x, expression)
-                                                listener: handleNoTypeArguments(-)
-                                                parseArgumentsOpt(x)
-                                                  listener: handleNoArguments(-)
-                                                listener: handleSend(x, -)
-                                        listener: beginBinaryExpression(-)
-                                        parsePrecedenceExpression(-, 14, true)
-                                          parseUnaryExpression(-, true)
-                                            parsePrimary(-, expression)
-                                              parseLiteralInt(-)
-                                                listener: handleLiteralInt(1)
-                                        listener: endBinaryExpression(-)
-                                    ensureCloseParen(1, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                              parseParenthesizedExpressionOrRecordLiteral(;)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(x, expression)
+                                            listener: handleNoTypeArguments(-)
+                                            parseArgumentsOpt(x)
+                                              listener: handleNoArguments(-)
+                                            listener: handleSend(x, -)
+                                    listener: beginBinaryExpression(-)
+                                    parsePrecedenceExpression(-, 14, true)
+                                      parseUnaryExpression(-, true)
+                                        parsePrimary(-, expression)
+                                          parseLiteralInt(-)
+                                            listener: handleLiteralInt(1)
+                                    listener: endBinaryExpression(-)
+                                ensureCloseParen(1, ()
+                                listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(+)
                         parsePrecedenceExpression(+, 14, true)
                           parseUnaryExpression(+, true)
@@ -7702,32 +7697,31 @@ parseUnit(int)
                         reportRecoverableErrorWithToken(return, Instance of 'Template<(Token) => Message>')
                           listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'return'., null, {lexeme: return}], return, return)
                         parsePrimary(return, expression)
-                          parseParenthesizedExpressionOrFunctionLiteral(return)
-                            parseParenthesizedExpression(return)
-                              parseExpressionInParenthesis(return)
-                                parseExpressionInParenthesisRest(()
-                                  parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
-                                          parseSendOrFunctionLiteral((, expression)
-                                            parseSend((, expression)
-                                              isNextIdentifier(()
-                                              ensureIdentifier((, expression)
-                                                listener: handleIdentifier(x, expression)
-                                              listener: handleNoTypeArguments(-)
-                                              parseArgumentsOpt(x)
-                                                listener: handleNoArguments(-)
-                                              listener: handleSend(x, -)
-                                      listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
-                                            parseLiteralInt(-)
-                                              listener: handleLiteralInt(1)
-                                      listener: endBinaryExpression(-)
-                                  ensureCloseParen(1, ()
-                              listener: handleParenthesizedExpression(()
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
+                            parseParenthesizedExpressionOrRecordLiteral(return)
+                              listener: beginParenthesizedExpressionOrRecordLiteral(()
+                              parseExpression(()
+                                parsePrecedenceExpression((, 1, true)
+                                  parseUnaryExpression((, true)
+                                    parsePrimary((, expression)
+                                      parseSendOrFunctionLiteral((, expression)
+                                        parseSend((, expression)
+                                          isNextIdentifier(()
+                                          ensureIdentifier((, expression)
+                                            listener: handleIdentifier(x, expression)
+                                          listener: handleNoTypeArguments(-)
+                                          parseArgumentsOpt(x)
+                                            listener: handleNoArguments(-)
+                                          listener: handleSend(x, -)
+                                  listener: beginBinaryExpression(-)
+                                  parsePrecedenceExpression(-, 14, true)
+                                    parseUnaryExpression(-, true)
+                                      parsePrimary(-, expression)
+                                        parseLiteralInt(-)
+                                          listener: handleLiteralInt(1)
+                                  listener: endBinaryExpression(-)
+                              ensureCloseParen(1, ()
+                              listener: endParenthesizedExpression(()
                     listener: beginBinaryExpression(+)
                     parsePrecedenceExpression(+, 14, true)
                       parseUnaryExpression(+, true)
@@ -8999,32 +8993,31 @@ parseUnit(int)
                       parsePrecedenceExpression(throw, 1, true)
                         parseUnaryExpression(throw, true)
                           parsePrimary(throw, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(throw)
-                              parseParenthesizedExpression(throw)
-                                parseExpressionInParenthesis(throw)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(x, expression)
-                                                listener: handleNoTypeArguments(-)
-                                                parseArgumentsOpt(x)
-                                                  listener: handleNoArguments(-)
-                                                listener: handleSend(x, -)
-                                        listener: beginBinaryExpression(-)
-                                        parsePrecedenceExpression(-, 14, true)
-                                          parseUnaryExpression(-, true)
-                                            parsePrimary(-, expression)
-                                              parseLiteralInt(-)
-                                                listener: handleLiteralInt(1)
-                                        listener: endBinaryExpression(-)
-                                    ensureCloseParen(1, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(throw)
+                              parseParenthesizedExpressionOrRecordLiteral(throw)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(x, expression)
+                                            listener: handleNoTypeArguments(-)
+                                            parseArgumentsOpt(x)
+                                              listener: handleNoArguments(-)
+                                            listener: handleSend(x, -)
+                                    listener: beginBinaryExpression(-)
+                                    parsePrecedenceExpression(-, 14, true)
+                                      parseUnaryExpression(-, true)
+                                        parsePrimary(-, expression)
+                                          parseLiteralInt(-)
+                                            listener: handleLiteralInt(1)
+                                    listener: endBinaryExpression(-)
+                                ensureCloseParen(1, ()
+                                listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(+)
                         parsePrecedenceExpression(+, 14, true)
                           parseUnaryExpression(+, true)
@@ -9320,32 +9313,31 @@ parseUnit(int)
                       parsePrecedenceExpression(}, 1, true)
                         parseUnaryExpression(}, true)
                           parsePrimary(}, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(})
-                              parseParenthesizedExpression(})
-                                parseExpressionInParenthesis(})
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(x, expression)
-                                                listener: handleNoTypeArguments(-)
-                                                parseArgumentsOpt(x)
-                                                  listener: handleNoArguments(-)
-                                                listener: handleSend(x, -)
-                                        listener: beginBinaryExpression(-)
-                                        parsePrecedenceExpression(-, 14, true)
-                                          parseUnaryExpression(-, true)
-                                            parsePrimary(-, expression)
-                                              parseLiteralInt(-)
-                                                listener: handleLiteralInt(1)
-                                        listener: endBinaryExpression(-)
-                                    ensureCloseParen(1, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(})
+                              parseParenthesizedExpressionOrRecordLiteral(})
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(x, expression)
+                                            listener: handleNoTypeArguments(-)
+                                            parseArgumentsOpt(x)
+                                              listener: handleNoArguments(-)
+                                            listener: handleSend(x, -)
+                                    listener: beginBinaryExpression(-)
+                                    parsePrecedenceExpression(-, 14, true)
+                                      parseUnaryExpression(-, true)
+                                        parsePrimary(-, expression)
+                                          parseLiteralInt(-)
+                                            listener: handleLiteralInt(1)
+                                    listener: endBinaryExpression(-)
+                                ensureCloseParen(1, ()
+                                listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(+)
                         parsePrecedenceExpression(+, 14, true)
                           parseUnaryExpression(+, true)

pkg/front_end/parser_testcases/general/augment_super.dart.expect

@@ -220,12 +220,13 @@ beginCompilationUnit(augment)
           endInitializedIdentifier(super)
           handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], super, super)
         endVariablesDeclaration(1, ;)
-        handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
-        handleIdentifier(, expression)
-        handleNoTypeArguments())
-        handleNoArguments())
-        handleSend(, ))
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
+          handleIdentifier(, expression)
+          handleNoTypeArguments())
+          handleNoArguments())
+          handleSend(, ))
+        endParenthesizedExpression(()
         handleExpressionStatement(;)
       endBlockFunctionBody(2, {, })
     endTopLevelMethod(void, null, })
@@ -437,12 +438,13 @@ beginCompilationUnit(augment)
           endInitializedIdentifier(super)
           handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], super, super)
         endVariablesDeclaration(1, ;)
-        handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
-        handleIdentifier(, expression)
-        handleNoTypeArguments())
-        handleNoArguments())
-        handleSend(, ))
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
+          handleIdentifier(, expression)
+          handleNoTypeArguments())
+          handleNoArguments())
+          handleSend(, ))
+        endParenthesizedExpression(()
         handleExpressionStatement(;)
         beginMetadataStar(augment)
         endMetadataStar(0)
@@ -540,12 +542,13 @@ beginCompilationUnit(augment)
                 endInitializedIdentifier(super)
                 handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], super, super)
               endVariablesDeclaration(1, ;)
-              handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
-              handleIdentifier(, expression)
-              handleNoTypeArguments())
-              handleNoArguments())
-              handleSend(, ))
-              handleParenthesizedExpression(()
+              beginParenthesizedExpressionOrRecordLiteral(()
+                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
+                handleIdentifier(, expression)
+                handleNoTypeArguments())
+                handleNoArguments())
+                handleSend(, ))
+              endParenthesizedExpression(()
               handleExpressionStatement(;)
             endBlockFunctionBody(2, {, })
           endClassMethod(null, void, (, null, })
@@ -740,12 +743,13 @@ beginCompilationUnit(augment)
                 endInitializedIdentifier(super)
                 handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], super, super)
               endVariablesDeclaration(1, ;)
-              handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
-              handleIdentifier(, expression)
-              handleNoTypeArguments())
-              handleNoArguments())
-              handleSend(, ))
-              handleParenthesizedExpression(()
+              beginParenthesizedExpressionOrRecordLiteral(()
+                handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
+                handleIdentifier(, expression)
+                handleNoTypeArguments())
+                handleNoArguments())
+                handleSend(, ))
+              endParenthesizedExpression(()
               handleExpressionStatement(;)
               beginMetadataStar(augment)
               endMetadataStar(0)

pkg/front_end/parser_testcases/general/augment_super.dart.intertwined.expect

@@ -85,27 +85,26 @@ parseUnit(augment)
                       parsePrecedenceExpression(;, 1, true)
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(;)
-                              parseParenthesizedExpression(;)
-                                parseExpressionInParenthesis(;)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSend((, expression)
-                                              isNextIdentifier(()
-                                              ensureIdentifier((, expression)
-                                                reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
-                                                  listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
-                                                rewriter()
-                                                listener: handleIdentifier(, expression)
-                                              listener: handleNoTypeArguments())
-                                              parseArgumentsOpt()
-                                                listener: handleNoArguments())
-                                              listener: handleSend(, ))
-                                    ensureCloseParen(, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                              parseParenthesizedExpressionOrRecordLiteral(;)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSend((, expression)
+                                          isNextIdentifier(()
+                                          ensureIdentifier((, expression)
+                                            reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
+                                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
+                                            rewriter()
+                                            listener: handleIdentifier(, expression)
+                                          listener: handleNoTypeArguments())
+                                          parseArgumentsOpt()
+                                            listener: handleNoArguments())
+                                          listener: handleSend(, ))
+                                ensureCloseParen(, ()
+                                listener: endParenthesizedExpression(()
                     ensureSemicolon())
                     listener: handleExpressionStatement(;)
           notEofOrValue(}, })
@@ -599,27 +598,26 @@ parseUnit(augment)
                       parsePrecedenceExpression(;, 1, true)
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(;)
-                              parseParenthesizedExpression(;)
-                                parseExpressionInParenthesis(;)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSend((, expression)
-                                              isNextIdentifier(()
-                                              ensureIdentifier((, expression)
-                                                reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
-                                                  listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
-                                                rewriter()
-                                                listener: handleIdentifier(, expression)
-                                              listener: handleNoTypeArguments())
-                                              parseArgumentsOpt()
-                                                listener: handleNoArguments())
-                                              listener: handleSend(, ))
-                                    ensureCloseParen(, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                              parseParenthesizedExpressionOrRecordLiteral(;)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSend((, expression)
+                                          isNextIdentifier(()
+                                          ensureIdentifier((, expression)
+                                            reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
+                                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
+                                            rewriter()
+                                            listener: handleIdentifier(, expression)
+                                          listener: handleNoTypeArguments())
+                                          parseArgumentsOpt()
+                                            listener: handleNoArguments())
+                                          listener: handleSend(, ))
+                                ensureCloseParen(, ()
+                                listener: endParenthesizedExpression(()
                     ensureSemicolon())
                     listener: handleExpressionStatement(;)
           notEofOrValue(}, augment)
@@ -848,27 +846,26 @@ parseUnit(augment)
                               parsePrecedenceExpression(;, 1, true)
                                 parseUnaryExpression(;, true)
                                   parsePrimary(;, expression)
-                                    parseParenthesizedExpressionOrFunctionLiteral(;)
-                                      parseParenthesizedExpression(;)
-                                        parseExpressionInParenthesis(;)
-                                          parseExpressionInParenthesisRest(()
-                                            parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
-                                                          listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
-                                                        rewriter()
-                                                        listener: handleIdentifier(, expression)
-                                                      listener: handleNoTypeArguments())
-                                                      parseArgumentsOpt()
-                                                        listener: handleNoArguments())
-                                                      listener: handleSend(, ))
-                                            ensureCloseParen(, ()
-                                        listener: handleParenthesizedExpression(()
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                                      parseParenthesizedExpressionOrRecordLiteral(;)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        parseExpression(()
+                                          parsePrecedenceExpression((, 1, true)
+                                            parseUnaryExpression((, true)
+                                              parsePrimary((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
+                                                      listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
+                                                    rewriter()
+                                                    listener: handleIdentifier(, expression)
+                                                  listener: handleNoTypeArguments())
+                                                  parseArgumentsOpt()
+                                                    listener: handleNoArguments())
+                                                  listener: handleSend(, ))
+                                        ensureCloseParen(, ()
+                                        listener: endParenthesizedExpression(()
                             ensureSemicolon())
                             listener: handleExpressionStatement(;)
                   notEofOrValue(}, })
@@ -1349,27 +1346,26 @@ parseUnit(augment)
                               parsePrecedenceExpression(;, 1, true)
                                 parseUnaryExpression(;, true)
                                   parsePrimary(;, expression)
-                                    parseParenthesizedExpressionOrFunctionLiteral(;)
-                                      parseParenthesizedExpression(;)
-                                        parseExpressionInParenthesis(;)
-                                          parseExpressionInParenthesisRest(()
-                                            parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
-                                                          listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
-                                                        rewriter()
-                                                        listener: handleIdentifier(, expression)
-                                                      listener: handleNoTypeArguments())
-                                                      parseArgumentsOpt()
-                                                        listener: handleNoArguments())
-                                                      listener: handleSend(, ))
-                                            ensureCloseParen(, ()
-                                        listener: handleParenthesizedExpression(()
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                                      parseParenthesizedExpressionOrRecordLiteral(;)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        parseExpression(()
+                                          parsePrecedenceExpression((, 1, true)
+                                            parseUnaryExpression((, true)
+                                              parsePrimary((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
+                                                      listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
+                                                    rewriter()
+                                                    listener: handleIdentifier(, expression)
+                                                  listener: handleNoTypeArguments())
+                                                  parseArgumentsOpt()
+                                                    listener: handleNoArguments())
+                                                  listener: handleSend(, ))
+                                        ensureCloseParen(, ()
+                                        listener: endParenthesizedExpression(()
                             ensureSemicolon())
                             listener: handleExpressionStatement(;)
                   notEofOrValue(}, augment)

pkg/front_end/parser_testcases/general/chained_call_05.dart.expect

@@ -19,12 +19,13 @@ beginCompilationUnit(void)
       endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
       handleAsyncModifier(null, null)
       beginBlockFunctionBody({)
-        handleIdentifier(e, expression)
-        handleNoTypeArguments(()
-        beginArguments(()
-        endArguments(0, (, ))
-        handleSend(e, ))
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(e, expression)
+          handleNoTypeArguments(()
+          beginArguments(()
+          endArguments(0, (, ))
+          handleSend(e, ))
+        endParenthesizedExpression(()
         beginTypeArguments(<)
           handleIdentifier(int, typeReference)
           handleNoTypeArguments(>)

pkg/front_end/parser_testcases/general/chained_call_05.dart.intertwined.expect

@@ -48,29 +48,28 @@ parseUnit(void)
                       parsePrecedenceExpression({, 1, true)
                         parseUnaryExpression({, true)
                           parsePrimary({, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral({)
-                              parseParenthesizedExpression({)
-                                parseExpressionInParenthesis({)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              looksLikeFunctionBody())
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(e, expression)
-                                                listener: handleNoTypeArguments(()
-                                                parseArgumentsOpt(e)
-                                                  parseArguments(e)
-                                                    parseArgumentsRest(()
-                                                      listener: beginArguments(()
-                                                      listener: endArguments(0, (, ))
-                                                listener: handleSend(e, ))
-                                    ensureCloseParen(), ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
+                              parseParenthesizedExpressionOrRecordLiteral({)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          looksLikeFunctionBody())
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(e, expression)
+                                            listener: handleNoTypeArguments(()
+                                            parseArgumentsOpt(e)
+                                              parseArguments(e)
+                                                parseArgumentsRest(()
+                                                  listener: beginArguments(()
+                                                  listener: endArguments(0, (, ))
+                                            listener: handleSend(e, ))
+                                ensureCloseParen(), ()
+                                listener: endParenthesizedExpression(()
                         listener: beginTypeArguments(<)
                         listener: handleIdentifier(int, typeReference)
                         listener: handleNoTypeArguments(>)

pkg/front_end/parser_testcases/general/chained_call_06.dart.expect

@@ -19,17 +19,18 @@ beginCompilationUnit(void)
       endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
       handleAsyncModifier(null, null)
       beginBlockFunctionBody({)
-        handleIdentifier(e, expression)
-        handleNoTypeArguments(.)
-        handleNoArguments(.)
-        handleSend(e, .)
-        handleIdentifier(f, expressionContinuation)
-        handleNoTypeArguments(()
-        beginArguments(()
-        endArguments(0, (, ))
-        handleSend(f, ))
-        handleEndingBinaryExpression(.)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(e, expression)
+          handleNoTypeArguments(.)
+          handleNoArguments(.)
+          handleSend(e, .)
+          handleIdentifier(f, expressionContinuation)
+          handleNoTypeArguments(()
+          beginArguments(()
+          endArguments(0, (, ))
+          handleSend(f, ))
+          handleEndingBinaryExpression(.)
+        endParenthesizedExpression(()
         beginTypeArguments(<)
           handleIdentifier(int, typeReference)
           handleNoTypeArguments(>)

pkg/front_end/parser_testcases/general/chained_call_06.dart.intertwined.expect

@@ -48,40 +48,39 @@ parseUnit(void)
                       parsePrecedenceExpression({, 1, true)
                         parseUnaryExpression({, true)
                           parsePrimary({, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral({)
-                              parseParenthesizedExpression({)
-                                parseExpressionInParenthesis({)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(e, expression)
-                                                listener: handleNoTypeArguments(.)
-                                                parseArgumentsOpt(e)
-                                                  listener: handleNoArguments(.)
-                                                listener: handleSend(e, .)
-                                        parsePrimary(., expressionContinuation)
-                                          parseSendOrFunctionLiteral(., expressionContinuation)
-                                            looksLikeFunctionBody())
-                                            parseSend(., expressionContinuation)
-                                              isNextIdentifier(.)
-                                              ensureIdentifier(., expressionContinuation)
-                                                listener: handleIdentifier(f, expressionContinuation)
-                                              listener: handleNoTypeArguments(()
-                                              parseArgumentsOpt(f)
-                                                parseArguments(f)
-                                                  parseArgumentsRest(()
-                                                    listener: beginArguments(()
-                                                    listener: endArguments(0, (, ))
-                                              listener: handleSend(f, ))
-                                        listener: handleEndingBinaryExpression(.)
-                                    ensureCloseParen(), ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
+                              parseParenthesizedExpressionOrRecordLiteral({)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(e, expression)
+                                            listener: handleNoTypeArguments(.)
+                                            parseArgumentsOpt(e)
+                                              listener: handleNoArguments(.)
+                                            listener: handleSend(e, .)
+                                    parsePrimary(., expressionContinuation)
+                                      parseSendOrFunctionLiteral(., expressionContinuation)
+                                        looksLikeFunctionBody())
+                                        parseSend(., expressionContinuation)
+                                          isNextIdentifier(.)
+                                          ensureIdentifier(., expressionContinuation)
+                                            listener: handleIdentifier(f, expressionContinuation)
+                                          listener: handleNoTypeArguments(()
+                                          parseArgumentsOpt(f)
+                                            parseArguments(f)
+                                              parseArgumentsRest(()
+                                                listener: beginArguments(()
+                                                listener: endArguments(0, (, ))
+                                          listener: handleSend(f, ))
+                                    listener: handleEndingBinaryExpression(.)
+                                ensureCloseParen(), ()
+                                listener: endParenthesizedExpression(()
                         listener: beginTypeArguments(<)
                         listener: handleIdentifier(int, typeReference)
                         listener: handleNoTypeArguments(>)

pkg/front_end/parser_testcases/general/function_expression.dart.intertwined.expect

@@ -37,7 +37,7 @@ parseUnit(main)
                       parsePrecedenceExpression({, 1, true)
                         parseUnaryExpression({, true)
                           parsePrimary({, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral({)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
                               listener: handleNoTypeVariables(()
                               parseFunctionExpression({)
                                 listener: beginFunctionExpression(()

pkg/front_end/parser_testcases/general/function_reference_following_token.dart.expect

@@ -578,11 +578,12 @@ beginCompilationUnit(var)
           handleNoArguments(>)
           handleSend(c, >)
           beginBinaryExpression(>)
-            handleIdentifier(d, expression)
-            handleNoTypeArguments())
-            handleNoArguments())
-            handleSend(d, ))
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleIdentifier(d, expression)
+              handleNoTypeArguments())
+              handleNoArguments())
+              handleSend(d, ))
+            endParenthesizedExpression(()
             handleUnaryPrefixExpression(!)
           endBinaryExpression(>)
         endArguments(2, (, ))

pkg/front_end/parser_testcases/general/function_reference_following_token.dart.intertwined.expect

@@ -1032,25 +1032,24 @@ parseUnit(var)
                                     parsePrecedenceExpression(!, 16, true)
                                       parseUnaryExpression(!, true)
                                         parsePrimary(!, expression)
-                                          parseParenthesizedExpressionOrFunctionLiteral(!)
-                                            parseParenthesizedExpression(!)
-                                              parseExpressionInParenthesis(!)
-                                                parseExpressionInParenthesisRest(()
-                                                  parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
-                                                          parseSendOrFunctionLiteral((, expression)
-                                                            parseSend((, expression)
-                                                              isNextIdentifier(()
-                                                              ensureIdentifier((, expression)
-                                                                listener: handleIdentifier(d, expression)
-                                                              listener: handleNoTypeArguments())
-                                                              parseArgumentsOpt(d)
-                                                                listener: handleNoArguments())
-                                                              listener: handleSend(d, ))
-                                                  ensureCloseParen(d, ()
-                                              listener: handleParenthesizedExpression(()
+                                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(!)
+                                            parseParenthesizedExpressionOrRecordLiteral(!)
+                                              listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                              parseExpression(()
+                                                parsePrecedenceExpression((, 1, true)
+                                                  parseUnaryExpression((, true)
+                                                    parsePrimary((, expression)
+                                                      parseSendOrFunctionLiteral((, expression)
+                                                        parseSend((, expression)
+                                                          isNextIdentifier(()
+                                                          ensureIdentifier((, expression)
+                                                            listener: handleIdentifier(d, expression)
+                                                          listener: handleNoTypeArguments())
+                                                          parseArgumentsOpt(d)
+                                                            listener: handleNoArguments())
+                                                          listener: handleSend(d, ))
+                                              ensureCloseParen(d, ()
+                                              listener: endParenthesizedExpression(()
                                     listener: handleUnaryPrefixExpression(!)
                                 listener: endBinaryExpression(>)
                             listener: endArguments(2, (, ))

pkg/front_end/parser_testcases/general/issue_45848_01.dart.expect

@@ -102,17 +102,18 @@ beginCompilationUnit(void)
             handleNoArguments(,)
             handleSend(y, ,)
           endBinaryExpression(<)
-          handleIdentifier(o, expression)
-          handleNoTypeArguments(as)
-          handleNoArguments(as)
-          handleSend(o, as)
-          beginAsOperatorType(as)
-            handleIdentifier(Function, typeReference)
-            handleNoTypeArguments())
-            handleType(Function, null)
-          endAsOperatorType(as)
-          handleAsOperator(as)
-          handleParenthesizedExpression(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleIdentifier(o, expression)
+            handleNoTypeArguments(as)
+            handleNoArguments(as)
+            handleSend(o, as)
+            beginAsOperatorType(as)
+              handleIdentifier(Function, typeReference)
+              handleNoTypeArguments())
+              handleType(Function, null)
+            endAsOperatorType(as)
+            handleAsOperator(as)
+          endParenthesizedExpression(()
           handleNoTypeArguments(()
           beginArguments(()
           endArguments(0, (, ))

pkg/front_end/parser_testcases/general/issue_45848_01.dart.intertwined.expect

@@ -223,34 +223,33 @@ parseUnit(void)
                                       parsePrecedenceExpression(,, 1, true)
                                         parseUnaryExpression(,, true)
                                           parsePrimary(,, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(,)
-                                              parseParenthesizedExpression(,)
-                                                parseExpressionInParenthesis(,)
-                                                  parseExpressionInParenthesisRest(()
-                                                    parseExpression(()
-                                                      parsePrecedenceExpression((, 1, true)
-                                                        parseUnaryExpression((, true)
-                                                          parsePrimary((, expression)
-                                                            parseSendOrFunctionLiteral((, expression)
-                                                              parseSend((, expression)
-                                                                isNextIdentifier(()
-                                                                ensureIdentifier((, expression)
-                                                                  listener: handleIdentifier(o, expression)
-                                                                listener: handleNoTypeArguments(as)
-                                                                parseArgumentsOpt(o)
-                                                                  listener: handleNoArguments(as)
-                                                                listener: handleSend(o, as)
-                                                        parseAsOperatorRest(o)
-                                                          listener: beginAsOperatorType(as)
-                                                          computeTypeAfterIsOrAs(as)
-                                                          listener: handleIdentifier(Function, typeReference)
-                                                          listener: handleNoTypeArguments())
-                                                          listener: handleType(Function, null)
-                                                          listener: endAsOperatorType(as)
-                                                          listener: handleAsOperator(as)
-                                                          skipChainedAsIsOperators(Function)
-                                                    ensureCloseParen(Function, ()
-                                                listener: handleParenthesizedExpression(()
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
+                                              parseParenthesizedExpressionOrRecordLiteral(,)
+                                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                parseExpression(()
+                                                  parsePrecedenceExpression((, 1, true)
+                                                    parseUnaryExpression((, true)
+                                                      parsePrimary((, expression)
+                                                        parseSendOrFunctionLiteral((, expression)
+                                                          parseSend((, expression)
+                                                            isNextIdentifier(()
+                                                            ensureIdentifier((, expression)
+                                                              listener: handleIdentifier(o, expression)
+                                                            listener: handleNoTypeArguments(as)
+                                                            parseArgumentsOpt(o)
+                                                              listener: handleNoArguments(as)
+                                                            listener: handleSend(o, as)
+                                                    parseAsOperatorRest(o)
+                                                      listener: beginAsOperatorType(as)
+                                                      computeTypeAfterIsOrAs(as)
+                                                      listener: handleIdentifier(Function, typeReference)
+                                                      listener: handleNoTypeArguments())
+                                                      listener: handleType(Function, null)
+                                                      listener: endAsOperatorType(as)
+                                                      listener: handleAsOperator(as)
+                                                      skipChainedAsIsOperators(Function)
+                                                ensureCloseParen(Function, ()
+                                                listener: endParenthesizedExpression(()
                                         parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
                                           listener: handleNoTypeArguments(()
                                           parseArguments())
@@ -327,7 +326,7 @@ parseUnit(void)
                                       parsePrecedenceExpression(,, 1, true)
                                         parseUnaryExpression(,, true)
                                           parsePrimary(,, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(,)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(,)
                                                 listener: beginFunctionExpression(()

pkg/front_end/parser_testcases/general/issue_45848_01.equivalence_info

@@ -4,4 +4,5 @@ files:
 filters:
   - ignoreListenerArguments
 ignored:
-  - handleParenthesizedExpression
+  - beginParenthesizedExpressionOrRecordLiteral
+  - endParenthesizedExpression

pkg/front_end/parser_testcases/general/issue_45848_01_prime.dart.expect

@@ -92,28 +92,30 @@ beginCompilationUnit(void)
         handleIdentifier(f, expression)
         handleNoTypeArguments(()
         beginArguments(()
-          handleIdentifier(x, expression)
-          handleNoTypeArguments(<)
-          handleNoArguments(<)
-          handleSend(x, <)
-          beginBinaryExpression(<)
-            handleIdentifier(y, expression)
-            handleNoTypeArguments())
-            handleNoArguments())
-            handleSend(y, ))
-          endBinaryExpression(<)
-          handleParenthesizedExpression(()
-          handleIdentifier(o, expression)
-          handleNoTypeArguments(as)
-          handleNoArguments(as)
-          handleSend(o, as)
-          beginAsOperatorType(as)
-            handleIdentifier(Function, typeReference)
-            handleNoTypeArguments())
-            handleType(Function, null)
-          endAsOperatorType(as)
-          handleAsOperator(as)
-          handleParenthesizedExpression(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleIdentifier(x, expression)
+            handleNoTypeArguments(<)
+            handleNoArguments(<)
+            handleSend(x, <)
+            beginBinaryExpression(<)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments())
+              handleNoArguments())
+              handleSend(y, ))
+            endBinaryExpression(<)
+          endParenthesizedExpression(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleIdentifier(o, expression)
+            handleNoTypeArguments(as)
+            handleNoArguments(as)
+            handleSend(o, as)
+            beginAsOperatorType(as)
+              handleIdentifier(Function, typeReference)
+              handleNoTypeArguments())
+              handleType(Function, null)
+            endAsOperatorType(as)
+            handleAsOperator(as)
+          endParenthesizedExpression(()
           handleNoTypeArguments(()
           beginArguments(()
           endArguments(0, (, ))

pkg/front_end/parser_testcases/general/issue_45848_01_prime.dart.intertwined.expect

@@ -195,71 +195,69 @@ parseUnit(void)
                                       parsePrecedenceExpression((, 1, true)
                                         parseUnaryExpression((, true)
                                           parsePrimary((, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(()
-                                              parseParenthesizedExpression(()
-                                                parseExpressionInParenthesis(()
-                                                  parseExpressionInParenthesisRest(()
-                                                    parseExpression(()
-                                                      parsePrecedenceExpression((, 1, true)
-                                                        parseUnaryExpression((, true)
-                                                          parsePrimary((, expression)
-                                                            parseSendOrFunctionLiteral((, expression)
-                                                              parseSend((, expression)
-                                                                isNextIdentifier(()
-                                                                ensureIdentifier((, expression)
-                                                                  listener: handleIdentifier(x, expression)
-                                                                listener: handleNoTypeArguments(<)
-                                                                parseArgumentsOpt(x)
-                                                                  listener: handleNoArguments(<)
-                                                                listener: handleSend(x, <)
-                                                        listener: beginBinaryExpression(<)
-                                                        parsePrecedenceExpression(<, 9, true)
-                                                          parseUnaryExpression(<, true)
-                                                            parsePrimary(<, expression)
-                                                              parseSendOrFunctionLiteral(<, expression)
-                                                                parseSend(<, expression)
-                                                                  isNextIdentifier(<)
-                                                                  ensureIdentifier(<, expression)
-                                                                    listener: handleIdentifier(y, expression)
-                                                                  listener: handleNoTypeArguments())
-                                                                  parseArgumentsOpt(y)
-                                                                    listener: handleNoArguments())
-                                                                  listener: handleSend(y, ))
-                                                        listener: endBinaryExpression(<)
-                                                    ensureCloseParen(y, ()
-                                                listener: handleParenthesizedExpression(()
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
+                                              parseParenthesizedExpressionOrRecordLiteral(()
+                                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                parseExpression(()
+                                                  parsePrecedenceExpression((, 1, true)
+                                                    parseUnaryExpression((, true)
+                                                      parsePrimary((, expression)
+                                                        parseSendOrFunctionLiteral((, expression)
+                                                          parseSend((, expression)
+                                                            isNextIdentifier(()
+                                                            ensureIdentifier((, expression)
+                                                              listener: handleIdentifier(x, expression)
+                                                            listener: handleNoTypeArguments(<)
+                                                            parseArgumentsOpt(x)
+                                                              listener: handleNoArguments(<)
+                                                            listener: handleSend(x, <)
+                                                    listener: beginBinaryExpression(<)
+                                                    parsePrecedenceExpression(<, 9, true)
+                                                      parseUnaryExpression(<, true)
+                                                        parsePrimary(<, expression)
+                                                          parseSendOrFunctionLiteral(<, expression)
+                                                            parseSend(<, expression)
+                                                              isNextIdentifier(<)
+                                                              ensureIdentifier(<, expression)
+                                                                listener: handleIdentifier(y, expression)
+                                                              listener: handleNoTypeArguments())
+                                                              parseArgumentsOpt(y)
+                                                                listener: handleNoArguments())
+                                                              listener: handleSend(y, ))
+                                                    listener: endBinaryExpression(<)
+                                                ensureCloseParen(y, ()
+                                                listener: endParenthesizedExpression(()
                                     parseExpression(,)
                                       parsePrecedenceExpression(,, 1, true)
                                         parseUnaryExpression(,, true)
                                           parsePrimary(,, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(,)
-                                              parseParenthesizedExpression(,)
-                                                parseExpressionInParenthesis(,)
-                                                  parseExpressionInParenthesisRest(()
-                                                    parseExpression(()
-                                                      parsePrecedenceExpression((, 1, true)
-                                                        parseUnaryExpression((, true)
-                                                          parsePrimary((, expression)
-                                                            parseSendOrFunctionLiteral((, expression)
-                                                              parseSend((, expression)
-                                                                isNextIdentifier(()
-                                                                ensureIdentifier((, expression)
-                                                                  listener: handleIdentifier(o, expression)
-                                                                listener: handleNoTypeArguments(as)
-                                                                parseArgumentsOpt(o)
-                                                                  listener: handleNoArguments(as)
-                                                                listener: handleSend(o, as)
-                                                        parseAsOperatorRest(o)
-                                                          listener: beginAsOperatorType(as)
-                                                          computeTypeAfterIsOrAs(as)
-                                                          listener: handleIdentifier(Function, typeReference)
-                                                          listener: handleNoTypeArguments())
-                                                          listener: handleType(Function, null)
-                                                          listener: endAsOperatorType(as)
-                                                          listener: handleAsOperator(as)
-                                                          skipChainedAsIsOperators(Function)
-                                                    ensureCloseParen(Function, ()
-                                                listener: handleParenthesizedExpression(()
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
+                                              parseParenthesizedExpressionOrRecordLiteral(,)
+                                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                parseExpression(()
+                                                  parsePrecedenceExpression((, 1, true)
+                                                    parseUnaryExpression((, true)
+                                                      parsePrimary((, expression)
+                                                        parseSendOrFunctionLiteral((, expression)
+                                                          parseSend((, expression)
+                                                            isNextIdentifier(()
+                                                            ensureIdentifier((, expression)
+                                                              listener: handleIdentifier(o, expression)
+                                                            listener: handleNoTypeArguments(as)
+                                                            parseArgumentsOpt(o)
+                                                              listener: handleNoArguments(as)
+                                                            listener: handleSend(o, as)
+                                                    parseAsOperatorRest(o)
+                                                      listener: beginAsOperatorType(as)
+                                                      computeTypeAfterIsOrAs(as)
+                                                      listener: handleIdentifier(Function, typeReference)
+                                                      listener: handleNoTypeArguments())
+                                                      listener: handleType(Function, null)
+                                                      listener: endAsOperatorType(as)
+                                                      listener: handleAsOperator(as)
+                                                      skipChainedAsIsOperators(Function)
+                                                ensureCloseParen(Function, ()
+                                                listener: endParenthesizedExpression(()
                                         parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
                                           listener: handleNoTypeArguments(()
                                           parseArguments())
@@ -336,7 +334,7 @@ parseUnit(void)
                                       parsePrecedenceExpression(,, 1, true)
                                         parseUnaryExpression(,, true)
                                           parsePrimary(,, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(,)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(,)
                                                 listener: beginFunctionExpression(()

pkg/front_end/parser_testcases/general/issue_45848_02.dart.expect

@@ -104,17 +104,18 @@ beginCompilationUnit(void)
           endBinaryExpression(<)
           handleLiteralInt(0)
           beginBinaryExpression(>)
-            handleIdentifier(o, expression)
-            handleNoTypeArguments(as)
-            handleNoArguments(as)
-            handleSend(o, as)
-            beginAsOperatorType(as)
-              handleIdentifier(int, typeReference)
-              handleNoTypeArguments())
-              handleType(int, null)
-            endAsOperatorType(as)
-            handleAsOperator(as)
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleIdentifier(o, expression)
+              handleNoTypeArguments(as)
+              handleNoArguments(as)
+              handleSend(o, as)
+              beginAsOperatorType(as)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments())
+                handleType(int, null)
+              endAsOperatorType(as)
+              handleAsOperator(as)
+            endParenthesizedExpression(()
           endBinaryExpression(>)
         endArguments(2, (, ))
         handleSend(f, ;)

pkg/front_end/parser_testcases/general/issue_45848_02.dart.intertwined.expect

@@ -229,34 +229,33 @@ parseUnit(void)
                                         parsePrecedenceExpression(>, 9, true)
                                           parseUnaryExpression(>, true)
                                             parsePrimary(>, expression)
-                                              parseParenthesizedExpressionOrFunctionLiteral(>)
-                                                parseParenthesizedExpression(>)
-                                                  parseExpressionInParenthesis(>)
-                                                    parseExpressionInParenthesisRest(()
-                                                      parseExpression(()
-                                                        parsePrecedenceExpression((, 1, true)
-                                                          parseUnaryExpression((, true)
-                                                            parsePrimary((, expression)
-                                                              parseSendOrFunctionLiteral((, expression)
-                                                                parseSend((, expression)
-                                                                  isNextIdentifier(()
-                                                                  ensureIdentifier((, expression)
-                                                                    listener: handleIdentifier(o, expression)
-                                                                  listener: handleNoTypeArguments(as)
-                                                                  parseArgumentsOpt(o)
-                                                                    listener: handleNoArguments(as)
-                                                                  listener: handleSend(o, as)
-                                                          parseAsOperatorRest(o)
-                                                            listener: beginAsOperatorType(as)
-                                                            computeTypeAfterIsOrAs(as)
-                                                            listener: handleIdentifier(int, typeReference)
-                                                            listener: handleNoTypeArguments())
-                                                            listener: handleType(int, null)
-                                                            listener: endAsOperatorType(as)
-                                                            listener: handleAsOperator(as)
-                                                            skipChainedAsIsOperators(int)
-                                                      ensureCloseParen(int, ()
-                                                  listener: handleParenthesizedExpression(()
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>)
+                                                parseParenthesizedExpressionOrRecordLiteral(>)
+                                                  listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                  parseExpression(()
+                                                    parsePrecedenceExpression((, 1, true)
+                                                      parseUnaryExpression((, true)
+                                                        parsePrimary((, expression)
+                                                          parseSendOrFunctionLiteral((, expression)
+                                                            parseSend((, expression)
+                                                              isNextIdentifier(()
+                                                              ensureIdentifier((, expression)
+                                                                listener: handleIdentifier(o, expression)
+                                                              listener: handleNoTypeArguments(as)
+                                                              parseArgumentsOpt(o)
+                                                                listener: handleNoArguments(as)
+                                                              listener: handleSend(o, as)
+                                                      parseAsOperatorRest(o)
+                                                        listener: beginAsOperatorType(as)
+                                                        computeTypeAfterIsOrAs(as)
+                                                        listener: handleIdentifier(int, typeReference)
+                                                        listener: handleNoTypeArguments())
+                                                        listener: handleType(int, null)
+                                                        listener: endAsOperatorType(as)
+                                                        listener: handleAsOperator(as)
+                                                        skipChainedAsIsOperators(int)
+                                                  ensureCloseParen(int, ()
+                                                  listener: endParenthesizedExpression(()
                                         listener: endBinaryExpression(>)
                                     listener: endArguments(2, (, ))
                               listener: handleSend(f, ;)

pkg/front_end/parser_testcases/general/issue_45848_02.equivalence_info

@@ -4,4 +4,5 @@ files:
 filters:
   - ignoreListenerArguments
 ignored:
-  - handleParenthesizedExpression
+  - beginParenthesizedExpressionOrRecordLiteral
+  - endParenthesizedExpression

pkg/front_end/parser_testcases/general/issue_45848_02_prime.dart.expect

@@ -92,30 +92,32 @@ beginCompilationUnit(void)
         handleIdentifier(f, expression)
         handleNoTypeArguments(()
         beginArguments(()
-          handleIdentifier(x, expression)
-          handleNoTypeArguments(<)
-          handleNoArguments(<)
-          handleSend(x, <)
-          beginBinaryExpression(<)
-            handleIdentifier(y, expression)
-            handleNoTypeArguments())
-            handleNoArguments())
-            handleSend(y, ))
-          endBinaryExpression(<)
-          handleParenthesizedExpression(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleIdentifier(x, expression)
+            handleNoTypeArguments(<)
+            handleNoArguments(<)
+            handleSend(x, <)
+            beginBinaryExpression(<)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments())
+              handleNoArguments())
+              handleSend(y, ))
+            endBinaryExpression(<)
+          endParenthesizedExpression(()
           handleLiteralInt(0)
           beginBinaryExpression(>)
-            handleIdentifier(o, expression)
-            handleNoTypeArguments(as)
-            handleNoArguments(as)
-            handleSend(o, as)
-            beginAsOperatorType(as)
-              handleIdentifier(int, typeReference)
-              handleNoTypeArguments())
-              handleType(int, null)
-            endAsOperatorType(as)
-            handleAsOperator(as)
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleIdentifier(o, expression)
+              handleNoTypeArguments(as)
+              handleNoArguments(as)
+              handleSend(o, as)
+              beginAsOperatorType(as)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments())
+                handleType(int, null)
+              endAsOperatorType(as)
+              handleAsOperator(as)
+            endParenthesizedExpression(()
           endBinaryExpression(>)
         endArguments(2, (, ))
         handleSend(f, ;)

pkg/front_end/parser_testcases/general/issue_45848_02_prime.dart.intertwined.expect

@@ -195,39 +195,38 @@ parseUnit(void)
                                       parsePrecedenceExpression((, 1, true)
                                         parseUnaryExpression((, true)
                                           parsePrimary((, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(()
-                                              parseParenthesizedExpression(()
-                                                parseExpressionInParenthesis(()
-                                                  parseExpressionInParenthesisRest(()
-                                                    parseExpression(()
-                                                      parsePrecedenceExpression((, 1, true)
-                                                        parseUnaryExpression((, true)
-                                                          parsePrimary((, expression)
-                                                            parseSendOrFunctionLiteral((, expression)
-                                                              parseSend((, expression)
-                                                                isNextIdentifier(()
-                                                                ensureIdentifier((, expression)
-                                                                  listener: handleIdentifier(x, expression)
-                                                                listener: handleNoTypeArguments(<)
-                                                                parseArgumentsOpt(x)
-                                                                  listener: handleNoArguments(<)
-                                                                listener: handleSend(x, <)
-                                                        listener: beginBinaryExpression(<)
-                                                        parsePrecedenceExpression(<, 9, true)
-                                                          parseUnaryExpression(<, true)
-                                                            parsePrimary(<, expression)
-                                                              parseSendOrFunctionLiteral(<, expression)
-                                                                parseSend(<, expression)
-                                                                  isNextIdentifier(<)
-                                                                  ensureIdentifier(<, expression)
-                                                                    listener: handleIdentifier(y, expression)
-                                                                  listener: handleNoTypeArguments())
-                                                                  parseArgumentsOpt(y)
-                                                                    listener: handleNoArguments())
-                                                                  listener: handleSend(y, ))
-                                                        listener: endBinaryExpression(<)
-                                                    ensureCloseParen(y, ()
-                                                listener: handleParenthesizedExpression(()
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
+                                              parseParenthesizedExpressionOrRecordLiteral(()
+                                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                parseExpression(()
+                                                  parsePrecedenceExpression((, 1, true)
+                                                    parseUnaryExpression((, true)
+                                                      parsePrimary((, expression)
+                                                        parseSendOrFunctionLiteral((, expression)
+                                                          parseSend((, expression)
+                                                            isNextIdentifier(()
+                                                            ensureIdentifier((, expression)
+                                                              listener: handleIdentifier(x, expression)
+                                                            listener: handleNoTypeArguments(<)
+                                                            parseArgumentsOpt(x)
+                                                              listener: handleNoArguments(<)
+                                                            listener: handleSend(x, <)
+                                                    listener: beginBinaryExpression(<)
+                                                    parsePrecedenceExpression(<, 9, true)
+                                                      parseUnaryExpression(<, true)
+                                                        parsePrimary(<, expression)
+                                                          parseSendOrFunctionLiteral(<, expression)
+                                                            parseSend(<, expression)
+                                                              isNextIdentifier(<)
+                                                              ensureIdentifier(<, expression)
+                                                                listener: handleIdentifier(y, expression)
+                                                              listener: handleNoTypeArguments())
+                                                              parseArgumentsOpt(y)
+                                                                listener: handleNoArguments())
+                                                              listener: handleSend(y, ))
+                                                    listener: endBinaryExpression(<)
+                                                ensureCloseParen(y, ()
+                                                listener: endParenthesizedExpression(()
                                     parseExpression(,)
                                       parsePrecedenceExpression(,, 1, true)
                                         parseUnaryExpression(,, true)
@@ -238,34 +237,33 @@ parseUnit(void)
                                         parsePrecedenceExpression(>, 9, true)
                                           parseUnaryExpression(>, true)
                                             parsePrimary(>, expression)
-                                              parseParenthesizedExpressionOrFunctionLiteral(>)
-                                                parseParenthesizedExpression(>)
-                                                  parseExpressionInParenthesis(>)
-                                                    parseExpressionInParenthesisRest(()
-                                                      parseExpression(()
-                                                        parsePrecedenceExpression((, 1, true)
-                                                          parseUnaryExpression((, true)
-                                                            parsePrimary((, expression)
-                                                              parseSendOrFunctionLiteral((, expression)
-                                                                parseSend((, expression)
-                                                                  isNextIdentifier(()
-                                                                  ensureIdentifier((, expression)
-                                                                    listener: handleIdentifier(o, expression)
-                                                                  listener: handleNoTypeArguments(as)
-                                                                  parseArgumentsOpt(o)
-                                                                    listener: handleNoArguments(as)
-                                                                  listener: handleSend(o, as)
-                                                          parseAsOperatorRest(o)
-                                                            listener: beginAsOperatorType(as)
-                                                            computeTypeAfterIsOrAs(as)
-                                                            listener: handleIdentifier(int, typeReference)
-                                                            listener: handleNoTypeArguments())
-                                                            listener: handleType(int, null)
-                                                            listener: endAsOperatorType(as)
-                                                            listener: handleAsOperator(as)
-                                                            skipChainedAsIsOperators(int)
-                                                      ensureCloseParen(int, ()
-                                                  listener: handleParenthesizedExpression(()
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>)
+                                                parseParenthesizedExpressionOrRecordLiteral(>)
+                                                  listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                  parseExpression(()
+                                                    parsePrecedenceExpression((, 1, true)
+                                                      parseUnaryExpression((, true)
+                                                        parsePrimary((, expression)
+                                                          parseSendOrFunctionLiteral((, expression)
+                                                            parseSend((, expression)
+                                                              isNextIdentifier(()
+                                                              ensureIdentifier((, expression)
+                                                                listener: handleIdentifier(o, expression)
+                                                              listener: handleNoTypeArguments(as)
+                                                              parseArgumentsOpt(o)
+                                                                listener: handleNoArguments(as)
+                                                              listener: handleSend(o, as)
+                                                      parseAsOperatorRest(o)
+                                                        listener: beginAsOperatorType(as)
+                                                        computeTypeAfterIsOrAs(as)
+                                                        listener: handleIdentifier(int, typeReference)
+                                                        listener: handleNoTypeArguments())
+                                                        listener: handleType(int, null)
+                                                        listener: endAsOperatorType(as)
+                                                        listener: handleAsOperator(as)
+                                                        skipChainedAsIsOperators(int)
+                                                  ensureCloseParen(int, ()
+                                                  listener: endParenthesizedExpression(()
                                         listener: endBinaryExpression(>)
                                     listener: endArguments(2, (, ))
                               listener: handleSend(f, ;)

pkg/front_end/parser_testcases/general/issue_45848_03.dart.expect

@@ -111,29 +111,31 @@ beginCompilationUnit(void)
             handleNoArguments(,)
             handleSend(y, ,)
           endBinaryExpression(<)
-          handleIdentifier(o, expression)
-          handleNoTypeArguments(as)
-          handleNoArguments(as)
-          handleSend(o, as)
-          beginAsOperatorType(as)
-            handleIdentifier(int, typeReference)
-            handleNoTypeArguments())
-            handleType(int, null)
-          endAsOperatorType(as)
-          handleAsOperator(as)
-          handleParenthesizedExpression(()
-          beginBinaryExpression(>)
-            handleIdentifier(p, expression)
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleIdentifier(o, expression)
             handleNoTypeArguments(as)
             handleNoArguments(as)
-            handleSend(p, as)
+            handleSend(o, as)
             beginAsOperatorType(as)
               handleIdentifier(int, typeReference)
               handleNoTypeArguments())
               handleType(int, null)
             endAsOperatorType(as)
             handleAsOperator(as)
-            handleParenthesizedExpression(()
+          endParenthesizedExpression(()
+          beginBinaryExpression(>)
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleIdentifier(p, expression)
+              handleNoTypeArguments(as)
+              handleNoArguments(as)
+              handleSend(p, as)
+              beginAsOperatorType(as)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments())
+                handleType(int, null)
+              endAsOperatorType(as)
+              handleAsOperator(as)
+            endParenthesizedExpression(()
           endBinaryExpression(>)
         endArguments(2, (, ))
         handleSend(f, ;)

pkg/front_end/parser_testcases/general/issue_45848_03.dart.intertwined.expect

@@ -235,66 +235,64 @@ parseUnit(void)
                                       parsePrecedenceExpression(,, 1, true)
                                         parseUnaryExpression(,, true)
                                           parsePrimary(,, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(,)
-                                              parseParenthesizedExpression(,)
-                                                parseExpressionInParenthesis(,)
-                                                  parseExpressionInParenthesisRest(()
-                                                    parseExpression(()
-                                                      parsePrecedenceExpression((, 1, true)
-                                                        parseUnaryExpression((, true)
-                                                          parsePrimary((, expression)
-                                                            parseSendOrFunctionLiteral((, expression)
-                                                              parseSend((, expression)
-                                                                isNextIdentifier(()
-                                                                ensureIdentifier((, expression)
-                                                                  listener: handleIdentifier(o, expression)
-                                                                listener: handleNoTypeArguments(as)
-                                                                parseArgumentsOpt(o)
-                                                                  listener: handleNoArguments(as)
-                                                                listener: handleSend(o, as)
-                                                        parseAsOperatorRest(o)
-                                                          listener: beginAsOperatorType(as)
-                                                          computeTypeAfterIsOrAs(as)
-                                                          listener: handleIdentifier(int, typeReference)
-                                                          listener: handleNoTypeArguments())
-                                                          listener: handleType(int, null)
-                                                          listener: endAsOperatorType(as)
-                                                          listener: handleAsOperator(as)
-                                                          skipChainedAsIsOperators(int)
-                                                    ensureCloseParen(int, ()
-                                                listener: handleParenthesizedExpression(()
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
+                                              parseParenthesizedExpressionOrRecordLiteral(,)
+                                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                parseExpression(()
+                                                  parsePrecedenceExpression((, 1, true)
+                                                    parseUnaryExpression((, true)
+                                                      parsePrimary((, expression)
+                                                        parseSendOrFunctionLiteral((, expression)
+                                                          parseSend((, expression)
+                                                            isNextIdentifier(()
+                                                            ensureIdentifier((, expression)
+                                                              listener: handleIdentifier(o, expression)
+                                                            listener: handleNoTypeArguments(as)
+                                                            parseArgumentsOpt(o)
+                                                              listener: handleNoArguments(as)
+                                                            listener: handleSend(o, as)
+                                                    parseAsOperatorRest(o)
+                                                      listener: beginAsOperatorType(as)
+                                                      computeTypeAfterIsOrAs(as)
+                                                      listener: handleIdentifier(int, typeReference)
+                                                      listener: handleNoTypeArguments())
+                                                      listener: handleType(int, null)
+                                                      listener: endAsOperatorType(as)
+                                                      listener: handleAsOperator(as)
+                                                      skipChainedAsIsOperators(int)
+                                                ensureCloseParen(int, ()
+                                                listener: endParenthesizedExpression(()
                                         listener: beginBinaryExpression(>)
                                         parsePrecedenceExpression(>, 9, true)
                                           parseUnaryExpression(>, true)
                                             parsePrimary(>, expression)
-                                              parseParenthesizedExpressionOrFunctionLiteral(>)
-                                                parseParenthesizedExpression(>)
-                                                  parseExpressionInParenthesis(>)
-                                                    parseExpressionInParenthesisRest(()
-                                                      parseExpression(()
-                                                        parsePrecedenceExpression((, 1, true)
-                                                          parseUnaryExpression((, true)
-                                                            parsePrimary((, expression)
-                                                              parseSendOrFunctionLiteral((, expression)
-                                                                parseSend((, expression)
-                                                                  isNextIdentifier(()
-                                                                  ensureIdentifier((, expression)
-                                                                    listener: handleIdentifier(p, expression)
-                                                                  listener: handleNoTypeArguments(as)
-                                                                  parseArgumentsOpt(p)
-                                                                    listener: handleNoArguments(as)
-                                                                  listener: handleSend(p, as)
-                                                          parseAsOperatorRest(p)
-                                                            listener: beginAsOperatorType(as)
-                                                            computeTypeAfterIsOrAs(as)
-                                                            listener: handleIdentifier(int, typeReference)
-                                                            listener: handleNoTypeArguments())
-                                                            listener: handleType(int, null)
-                                                            listener: endAsOperatorType(as)
-                                                            listener: handleAsOperator(as)
-                                                            skipChainedAsIsOperators(int)
-                                                      ensureCloseParen(int, ()
-                                                  listener: handleParenthesizedExpression(()
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>)
+                                                parseParenthesizedExpressionOrRecordLiteral(>)
+                                                  listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                  parseExpression(()
+                                                    parsePrecedenceExpression((, 1, true)
+                                                      parseUnaryExpression((, true)
+                                                        parsePrimary((, expression)
+                                                          parseSendOrFunctionLiteral((, expression)
+                                                            parseSend((, expression)
+                                                              isNextIdentifier(()
+                                                              ensureIdentifier((, expression)
+                                                                listener: handleIdentifier(p, expression)
+                                                              listener: handleNoTypeArguments(as)
+                                                              parseArgumentsOpt(p)
+                                                                listener: handleNoArguments(as)
+                                                              listener: handleSend(p, as)
+                                                      parseAsOperatorRest(p)
+                                                        listener: beginAsOperatorType(as)
+                                                        computeTypeAfterIsOrAs(as)
+                                                        listener: handleIdentifier(int, typeReference)
+                                                        listener: handleNoTypeArguments())
+                                                        listener: handleType(int, null)
+                                                        listener: endAsOperatorType(as)
+                                                        listener: handleAsOperator(as)
+                                                        skipChainedAsIsOperators(int)
+                                                  ensureCloseParen(int, ()
+                                                  listener: endParenthesizedExpression(()
                                         listener: endBinaryExpression(>)
                                     listener: endArguments(2, (, ))
                               listener: handleSend(f, ;)

pkg/front_end/parser_testcases/general/issue_45848_03.equivalence_info

@@ -4,4 +4,5 @@ files:
 filters:
   - ignoreListenerArguments
 ignored:
-  - handleParenthesizedExpression
+  - beginParenthesizedExpressionOrRecordLiteral
+  - endParenthesizedExpression

pkg/front_end/parser_testcases/general/issue_45848_03_prime.dart.expect

@@ -101,40 +101,43 @@ beginCompilationUnit(void)
         handleIdentifier(f, expression)
         handleNoTypeArguments(()
         beginArguments(()
-          handleIdentifier(x, expression)
-          handleNoTypeArguments(<)
-          handleNoArguments(<)
-          handleSend(x, <)
-          beginBinaryExpression(<)
-            handleIdentifier(y, expression)
-            handleNoTypeArguments())
-            handleNoArguments())
-            handleSend(y, ))
-          endBinaryExpression(<)
-          handleParenthesizedExpression(()
-          handleIdentifier(o, expression)
-          handleNoTypeArguments(as)
-          handleNoArguments(as)
-          handleSend(o, as)
-          beginAsOperatorType(as)
-            handleIdentifier(int, typeReference)
-            handleNoTypeArguments())
-            handleType(int, null)
-          endAsOperatorType(as)
-          handleAsOperator(as)
-          handleParenthesizedExpression(()
-          beginBinaryExpression(>)
-            handleIdentifier(p, expression)
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleIdentifier(x, expression)
+            handleNoTypeArguments(<)
+            handleNoArguments(<)
+            handleSend(x, <)
+            beginBinaryExpression(<)
+              handleIdentifier(y, expression)
+              handleNoTypeArguments())
+              handleNoArguments())
+              handleSend(y, ))
+            endBinaryExpression(<)
+          endParenthesizedExpression(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleIdentifier(o, expression)
             handleNoTypeArguments(as)
             handleNoArguments(as)
-            handleSend(p, as)
+            handleSend(o, as)
             beginAsOperatorType(as)
               handleIdentifier(int, typeReference)
               handleNoTypeArguments())
               handleType(int, null)
             endAsOperatorType(as)
             handleAsOperator(as)
-            handleParenthesizedExpression(()
+          endParenthesizedExpression(()
+          beginBinaryExpression(>)
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleIdentifier(p, expression)
+              handleNoTypeArguments(as)
+              handleNoArguments(as)
+              handleSend(p, as)
+              beginAsOperatorType(as)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments())
+                handleType(int, null)
+              endAsOperatorType(as)
+              handleAsOperator(as)
+            endParenthesizedExpression(()
           endBinaryExpression(>)
         endArguments(2, (, ))
         handleSend(f, ;)

pkg/front_end/parser_testcases/general/issue_45848_03_prime.dart.intertwined.expect

@@ -207,103 +207,100 @@ parseUnit(void)
                                       parsePrecedenceExpression((, 1, true)
                                         parseUnaryExpression((, true)
                                           parsePrimary((, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(()
-                                              parseParenthesizedExpression(()
-                                                parseExpressionInParenthesis(()
-                                                  parseExpressionInParenthesisRest(()
-                                                    parseExpression(()
-                                                      parsePrecedenceExpression((, 1, true)
-                                                        parseUnaryExpression((, true)
-                                                          parsePrimary((, expression)
-                                                            parseSendOrFunctionLiteral((, expression)
-                                                              parseSend((, expression)
-                                                                isNextIdentifier(()
-                                                                ensureIdentifier((, expression)
-                                                                  listener: handleIdentifier(x, expression)
-                                                                listener: handleNoTypeArguments(<)
-                                                                parseArgumentsOpt(x)
-                                                                  listener: handleNoArguments(<)
-                                                                listener: handleSend(x, <)
-                                                        listener: beginBinaryExpression(<)
-                                                        parsePrecedenceExpression(<, 9, true)
-                                                          parseUnaryExpression(<, true)
-                                                            parsePrimary(<, expression)
-                                                              parseSendOrFunctionLiteral(<, expression)
-                                                                parseSend(<, expression)
-                                                                  isNextIdentifier(<)
-                                                                  ensureIdentifier(<, expression)
-                                                                    listener: handleIdentifier(y, expression)
-                                                                  listener: handleNoTypeArguments())
-                                                                  parseArgumentsOpt(y)
-                                                                    listener: handleNoArguments())
-                                                                  listener: handleSend(y, ))
-                                                        listener: endBinaryExpression(<)
-                                                    ensureCloseParen(y, ()
-                                                listener: handleParenthesizedExpression(()
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
+                                              parseParenthesizedExpressionOrRecordLiteral(()
+                                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                parseExpression(()
+                                                  parsePrecedenceExpression((, 1, true)
+                                                    parseUnaryExpression((, true)
+                                                      parsePrimary((, expression)
+                                                        parseSendOrFunctionLiteral((, expression)
+                                                          parseSend((, expression)
+                                                            isNextIdentifier(()
+                                                            ensureIdentifier((, expression)
+                                                              listener: handleIdentifier(x, expression)
+                                                            listener: handleNoTypeArguments(<)
+                                                            parseArgumentsOpt(x)
+                                                              listener: handleNoArguments(<)
+                                                            listener: handleSend(x, <)
+                                                    listener: beginBinaryExpression(<)
+                                                    parsePrecedenceExpression(<, 9, true)
+                                                      parseUnaryExpression(<, true)
+                                                        parsePrimary(<, expression)
+                                                          parseSendOrFunctionLiteral(<, expression)
+                                                            parseSend(<, expression)
+                                                              isNextIdentifier(<)
+                                                              ensureIdentifier(<, expression)
+                                                                listener: handleIdentifier(y, expression)
+                                                              listener: handleNoTypeArguments())
+                                                              parseArgumentsOpt(y)
+                                                                listener: handleNoArguments())
+                                                              listener: handleSend(y, ))
+                                                    listener: endBinaryExpression(<)
+                                                ensureCloseParen(y, ()
+                                                listener: endParenthesizedExpression(()
                                     parseExpression(,)
                                       parsePrecedenceExpression(,, 1, true)
                                         parseUnaryExpression(,, true)
                                           parsePrimary(,, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(,)
-                                              parseParenthesizedExpression(,)
-                                                parseExpressionInParenthesis(,)
-                                                  parseExpressionInParenthesisRest(()
-                                                    parseExpression(()
-                                                      parsePrecedenceExpression((, 1, true)
-                                                        parseUnaryExpression((, true)
-                                                          parsePrimary((, expression)
-                                                            parseSendOrFunctionLiteral((, expression)
-                                                              parseSend((, expression)
-                                                                isNextIdentifier(()
-                                                                ensureIdentifier((, expression)
-                                                                  listener: handleIdentifier(o, expression)
-                                                                listener: handleNoTypeArguments(as)
-                                                                parseArgumentsOpt(o)
-                                                                  listener: handleNoArguments(as)
-                                                                listener: handleSend(o, as)
-                                                        parseAsOperatorRest(o)
-                                                          listener: beginAsOperatorType(as)
-                                                          computeTypeAfterIsOrAs(as)
-                                                          listener: handleIdentifier(int, typeReference)
-                                                          listener: handleNoTypeArguments())
-                                                          listener: handleType(int, null)
-                                                          listener: endAsOperatorType(as)
-                                                          listener: handleAsOperator(as)
-                                                          skipChainedAsIsOperators(int)
-                                                    ensureCloseParen(int, ()
-                                                listener: handleParenthesizedExpression(()
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
+                                              parseParenthesizedExpressionOrRecordLiteral(,)
+                                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                parseExpression(()
+                                                  parsePrecedenceExpression((, 1, true)
+                                                    parseUnaryExpression((, true)
+                                                      parsePrimary((, expression)
+                                                        parseSendOrFunctionLiteral((, expression)
+                                                          parseSend((, expression)
+                                                            isNextIdentifier(()
+                                                            ensureIdentifier((, expression)
+                                                              listener: handleIdentifier(o, expression)
+                                                            listener: handleNoTypeArguments(as)
+                                                            parseArgumentsOpt(o)
+                                                              listener: handleNoArguments(as)
+                                                            listener: handleSend(o, as)
+                                                    parseAsOperatorRest(o)
+                                                      listener: beginAsOperatorType(as)
+                                                      computeTypeAfterIsOrAs(as)
+                                                      listener: handleIdentifier(int, typeReference)
+                                                      listener: handleNoTypeArguments())
+                                                      listener: handleType(int, null)
+                                                      listener: endAsOperatorType(as)
+                                                      listener: handleAsOperator(as)
+                                                      skipChainedAsIsOperators(int)
+                                                ensureCloseParen(int, ()
+                                                listener: endParenthesizedExpression(()
                                         listener: beginBinaryExpression(>)
                                         parsePrecedenceExpression(>, 9, true)
                                           parseUnaryExpression(>, true)
                                             parsePrimary(>, expression)
-                                              parseParenthesizedExpressionOrFunctionLiteral(>)
-                                                parseParenthesizedExpression(>)
-                                                  parseExpressionInParenthesis(>)
-                                                    parseExpressionInParenthesisRest(()
-                                                      parseExpression(()
-                                                        parsePrecedenceExpression((, 1, true)
-                                                          parseUnaryExpression((, true)
-                                                            parsePrimary((, expression)
-                                                              parseSendOrFunctionLiteral((, expression)
-                                                                parseSend((, expression)
-                                                                  isNextIdentifier(()
-                                                                  ensureIdentifier((, expression)
-                                                                    listener: handleIdentifier(p, expression)
-                                                                  listener: handleNoTypeArguments(as)
-                                                                  parseArgumentsOpt(p)
-                                                                    listener: handleNoArguments(as)
-                                                                  listener: handleSend(p, as)
-                                                          parseAsOperatorRest(p)
-                                                            listener: beginAsOperatorType(as)
-                                                            computeTypeAfterIsOrAs(as)
-                                                            listener: handleIdentifier(int, typeReference)
-                                                            listener: handleNoTypeArguments())
-                                                            listener: handleType(int, null)
-                                                            listener: endAsOperatorType(as)
-                                                            listener: handleAsOperator(as)
-                                                            skipChainedAsIsOperators(int)
-                                                      ensureCloseParen(int, ()
-                                                  listener: handleParenthesizedExpression(()
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>)
+                                                parseParenthesizedExpressionOrRecordLiteral(>)
+                                                  listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                  parseExpression(()
+                                                    parsePrecedenceExpression((, 1, true)
+                                                      parseUnaryExpression((, true)
+                                                        parsePrimary((, expression)
+                                                          parseSendOrFunctionLiteral((, expression)
+                                                            parseSend((, expression)
+                                                              isNextIdentifier(()
+                                                              ensureIdentifier((, expression)
+                                                                listener: handleIdentifier(p, expression)
+                                                              listener: handleNoTypeArguments(as)
+                                                              parseArgumentsOpt(p)
+                                                                listener: handleNoArguments(as)
+                                                              listener: handleSend(p, as)
+                                                      parseAsOperatorRest(p)
+                                                        listener: beginAsOperatorType(as)
+                                                        computeTypeAfterIsOrAs(as)
+                                                        listener: handleIdentifier(int, typeReference)
+                                                        listener: handleNoTypeArguments())
+                                                        listener: handleType(int, null)
+                                                        listener: endAsOperatorType(as)
+                                                        listener: handleAsOperator(as)
+                                                        skipChainedAsIsOperators(int)
+                                                  ensureCloseParen(int, ()
+                                                  listener: endParenthesizedExpression(()
                                         listener: endBinaryExpression(>)
                                     listener: endArguments(2, (, ))
                               listener: handleSend(f, ;)

pkg/front_end/parser_testcases/general/issue_47008_01.dart.expect

@@ -35,8 +35,9 @@ beginCompilationUnit(main)
           endBinaryExpression(<)
           handleLiteralInt(1)
           beginBinaryExpression(>>)
-            handleLiteralInt(2)
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleLiteralInt(2)
+            endParenthesizedExpression(()
           endBinaryExpression(>>)
         endArguments(3, (, ))
         handleSend(a, ;)

pkg/front_end/parser_testcases/general/issue_47008_01.dart.intertwined.expect

@@ -112,18 +112,17 @@ parseUnit(main)
                                         parsePrecedenceExpression(>>, 13, true)
                                           parseUnaryExpression(>>, true)
                                             parsePrimary(>>, expression)
-                                              parseParenthesizedExpressionOrFunctionLiteral(>>)
-                                                parseParenthesizedExpression(>>)
-                                                  parseExpressionInParenthesis(>>)
-                                                    parseExpressionInParenthesisRest(()
-                                                      parseExpression(()
-                                                        parsePrecedenceExpression((, 1, true)
-                                                          parseUnaryExpression((, true)
-                                                            parsePrimary((, expression)
-                                                              parseLiteralInt(()
-                                                                listener: handleLiteralInt(2)
-                                                      ensureCloseParen(2, ()
-                                                  listener: handleParenthesizedExpression(()
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>>)
+                                                parseParenthesizedExpressionOrRecordLiteral(>>)
+                                                  listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                  parseExpression(()
+                                                    parsePrecedenceExpression((, 1, true)
+                                                      parseUnaryExpression((, true)
+                                                        parsePrimary((, expression)
+                                                          parseLiteralInt(()
+                                                            listener: handleLiteralInt(2)
+                                                  ensureCloseParen(2, ()
+                                                  listener: endParenthesizedExpression(()
                                         listener: endBinaryExpression(>>)
                                     listener: endArguments(3, (, ))
                               listener: handleSend(a, ;)

pkg/front_end/parser_testcases/general/issue_47008_02.dart.expect

@@ -45,8 +45,9 @@ beginCompilationUnit(main)
           endBinaryExpression(<)
           handleLiteralInt(1)
           beginBinaryExpression(>>>)
-            handleLiteralInt(2)
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleLiteralInt(2)
+            endParenthesizedExpression(()
           endBinaryExpression(>>>)
         endArguments(4, (, ))
         handleSend(a, ;)

pkg/front_end/parser_testcases/general/issue_47008_02.dart.intertwined.expect

@@ -139,18 +139,17 @@ parseUnit(main)
                                         parsePrecedenceExpression(>>>, 13, true)
                                           parseUnaryExpression(>>>, true)
                                             parsePrimary(>>>, expression)
-                                              parseParenthesizedExpressionOrFunctionLiteral(>>>)
-                                                parseParenthesizedExpression(>>>)
-                                                  parseExpressionInParenthesis(>>>)
-                                                    parseExpressionInParenthesisRest(()
-                                                      parseExpression(()
-                                                        parsePrecedenceExpression((, 1, true)
-                                                          parseUnaryExpression((, true)
-                                                            parsePrimary((, expression)
-                                                              parseLiteralInt(()
-                                                                listener: handleLiteralInt(2)
-                                                      ensureCloseParen(2, ()
-                                                  listener: handleParenthesizedExpression(()
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>>>)
+                                                parseParenthesizedExpressionOrRecordLiteral(>>>)
+                                                  listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                  parseExpression(()
+                                                    parsePrecedenceExpression((, 1, true)
+                                                      parseUnaryExpression((, true)
+                                                        parsePrimary((, expression)
+                                                          parseLiteralInt(()
+                                                            listener: handleLiteralInt(2)
+                                                  ensureCloseParen(2, ()
+                                                  listener: endParenthesizedExpression(()
                                         listener: endBinaryExpression(>>>)
                                     listener: endArguments(4, (, ))
                               listener: handleSend(a, ;)

pkg/front_end/parser_testcases/general/issue_47009_01.dart.expect

@@ -28,8 +28,9 @@ beginCompilationUnit(main)
           handleNoArguments(>)
           handleSend(as, >)
           beginBinaryExpression(>)
-            handleLiteralInt(1)
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleLiteralInt(1)
+            endParenthesizedExpression(()
           endBinaryExpression(>)
         endArguments(2, (, ))
         handleSend(a, ;)

pkg/front_end/parser_testcases/general/issue_47009_01.dart.intertwined.expect

@@ -94,18 +94,17 @@ parseUnit(main)
                                         parsePrecedenceExpression(>, 9, true)
                                           parseUnaryExpression(>, true)
                                             parsePrimary(>, expression)
-                                              parseParenthesizedExpressionOrFunctionLiteral(>)
-                                                parseParenthesizedExpression(>)
-                                                  parseExpressionInParenthesis(>)
-                                                    parseExpressionInParenthesisRest(()
-                                                      parseExpression(()
-                                                        parsePrecedenceExpression((, 1, true)
-                                                          parseUnaryExpression((, true)
-                                                            parsePrimary((, expression)
-                                                              parseLiteralInt(()
-                                                                listener: handleLiteralInt(1)
-                                                      ensureCloseParen(1, ()
-                                                  listener: handleParenthesizedExpression(()
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>)
+                                                parseParenthesizedExpressionOrRecordLiteral(>)
+                                                  listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                  parseExpression(()
+                                                    parsePrecedenceExpression((, 1, true)
+                                                      parseUnaryExpression((, true)
+                                                        parsePrimary((, expression)
+                                                          parseLiteralInt(()
+                                                            listener: handleLiteralInt(1)
+                                                  ensureCloseParen(1, ()
+                                                  listener: endParenthesizedExpression(()
                                         listener: endBinaryExpression(>)
                                     listener: endArguments(2, (, ))
                               listener: handleSend(a, ;)

pkg/front_end/parser_testcases/general/issue_47009_02.dart.expect

@@ -38,8 +38,9 @@ beginCompilationUnit(main)
           handleNoArguments(>>)
           handleSend(as, >>)
           beginBinaryExpression(>>)
-            handleLiteralInt(1)
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleLiteralInt(1)
+            endParenthesizedExpression(()
           endBinaryExpression(>>)
         endArguments(3, (, ))
         handleSend(a, ;)

pkg/front_end/parser_testcases/general/issue_47009_02.dart.intertwined.expect

@@ -121,18 +121,17 @@ parseUnit(main)
                                         parsePrecedenceExpression(>>, 13, true)
                                           parseUnaryExpression(>>, true)
                                             parsePrimary(>>, expression)
-                                              parseParenthesizedExpressionOrFunctionLiteral(>>)
-                                                parseParenthesizedExpression(>>)
-                                                  parseExpressionInParenthesis(>>)
-                                                    parseExpressionInParenthesisRest(()
-                                                      parseExpression(()
-                                                        parsePrecedenceExpression((, 1, true)
-                                                          parseUnaryExpression((, true)
-                                                            parsePrimary((, expression)
-                                                              parseLiteralInt(()
-                                                                listener: handleLiteralInt(1)
-                                                      ensureCloseParen(1, ()
-                                                  listener: handleParenthesizedExpression(()
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>>)
+                                                parseParenthesizedExpressionOrRecordLiteral(>>)
+                                                  listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                  parseExpression(()
+                                                    parsePrecedenceExpression((, 1, true)
+                                                      parseUnaryExpression((, true)
+                                                        parsePrimary((, expression)
+                                                          parseLiteralInt(()
+                                                            listener: handleLiteralInt(1)
+                                                  ensureCloseParen(1, ()
+                                                  listener: endParenthesizedExpression(()
                                         listener: endBinaryExpression(>>)
                                     listener: endArguments(3, (, ))
                               listener: handleSend(a, ;)

pkg/front_end/parser_testcases/general/issue_47009_03.dart.expect

@@ -48,8 +48,9 @@ beginCompilationUnit(main)
           handleNoArguments(>>>)
           handleSend(as, >>>)
           beginBinaryExpression(>>>)
-            handleLiteralInt(1)
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleLiteralInt(1)
+            endParenthesizedExpression(()
           endBinaryExpression(>>>)
         endArguments(4, (, ))
         handleSend(a, ;)

pkg/front_end/parser_testcases/general/issue_47009_03.dart.intertwined.expect

@@ -148,18 +148,17 @@ parseUnit(main)
                                         parsePrecedenceExpression(>>>, 13, true)
                                           parseUnaryExpression(>>>, true)
                                             parsePrimary(>>>, expression)
-                                              parseParenthesizedExpressionOrFunctionLiteral(>>>)
-                                                parseParenthesizedExpression(>>>)
-                                                  parseExpressionInParenthesis(>>>)
-                                                    parseExpressionInParenthesisRest(()
-                                                      parseExpression(()
-                                                        parsePrecedenceExpression((, 1, true)
-                                                          parseUnaryExpression((, true)
-                                                            parsePrimary((, expression)
-                                                              parseLiteralInt(()
-                                                                listener: handleLiteralInt(1)
-                                                      ensureCloseParen(1, ()
-                                                  listener: handleParenthesizedExpression(()
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>>>)
+                                                parseParenthesizedExpressionOrRecordLiteral(>>>)
+                                                  listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                  parseExpression(()
+                                                    parsePrecedenceExpression((, 1, true)
+                                                      parseUnaryExpression((, true)
+                                                        parsePrimary((, expression)
+                                                          parseLiteralInt(()
+                                                            listener: handleLiteralInt(1)
+                                                  ensureCloseParen(1, ()
+                                                  listener: endParenthesizedExpression(()
                                         listener: endBinaryExpression(>>>)
                                     listener: endArguments(4, (, ))
                               listener: handleSend(a, ;)

pkg/front_end/parser_testcases/nnbd/chained_call_05.dart.expect

@@ -19,16 +19,17 @@ beginCompilationUnit(void)
       endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
       handleAsyncModifier(null, null)
       beginBlockFunctionBody({)
-        handleIdentifier(e, expression)
-        handleNoTypeArguments(!)
-        handleNoArguments(!)
-        handleSend(e, !)
-        handleNonNullAssertExpression(!)
-        handleNoTypeArguments(()
-        beginArguments(()
-        endArguments(0, (, ))
-        handleSend((, ))
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(e, expression)
+          handleNoTypeArguments(!)
+          handleNoArguments(!)
+          handleSend(e, !)
+          handleNonNullAssertExpression(!)
+          handleNoTypeArguments(()
+          beginArguments(()
+          endArguments(0, (, ))
+          handleSend((, ))
+        endParenthesizedExpression(()
         handleNonNullAssertExpression(!)
         beginTypeArguments(<)
           handleIdentifier(int, typeReference)
@@ -40,17 +41,18 @@ beginCompilationUnit(void)
         handleSend((, ))
         handleNonNullAssertExpression(!)
         handleExpressionStatement(;)
-        handleIdentifier(e, expression)
-        handleNoTypeArguments(!)
-        handleNoArguments(!)
-        handleSend(e, !)
-        handleNonNullAssertExpression(!)
-        handleNoTypeArguments(()
-        beginArguments(()
-        endArguments(0, (, ))
-        handleSend((, ))
-        handleNonNullAssertExpression(!)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(e, expression)
+          handleNoTypeArguments(!)
+          handleNoArguments(!)
+          handleSend(e, !)
+          handleNonNullAssertExpression(!)
+          handleNoTypeArguments(()
+          beginArguments(()
+          endArguments(0, (, ))
+          handleSend((, ))
+          handleNonNullAssertExpression(!)
+        endParenthesizedExpression(()
         beginTypeArguments(<)
           handleIdentifier(int, typeReference)
           handleNoTypeArguments(>)

pkg/front_end/parser_testcases/nnbd/chained_call_05.dart.intertwined.expect

@@ -48,33 +48,32 @@ parseUnit(void)
                       parsePrecedenceExpression({, 1, true)
                         parseUnaryExpression({, true)
                           parsePrimary({, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral({)
-                              parseParenthesizedExpression({)
-                                parseExpressionInParenthesis({)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(e, expression)
-                                                listener: handleNoTypeArguments(!)
-                                                parseArgumentsOpt(e)
-                                                  listener: handleNoArguments(!)
-                                                listener: handleSend(e, !)
-                                        listener: handleNonNullAssertExpression(!)
-                                        parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
-                                          listener: handleNoTypeArguments(()
-                                          parseArguments(!)
-                                            parseArgumentsRest(()
-                                              listener: beginArguments(()
-                                              listener: endArguments(0, (, ))
-                                          listener: handleSend((, ))
-                                    ensureCloseParen(), ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
+                              parseParenthesizedExpressionOrRecordLiteral({)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(e, expression)
+                                            listener: handleNoTypeArguments(!)
+                                            parseArgumentsOpt(e)
+                                              listener: handleNoArguments(!)
+                                            listener: handleSend(e, !)
+                                    listener: handleNonNullAssertExpression(!)
+                                    parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
+                                      listener: handleNoTypeArguments(()
+                                      parseArguments(!)
+                                        parseArgumentsRest(()
+                                          listener: beginArguments(()
+                                          listener: endArguments(0, (, ))
+                                      listener: handleSend((, ))
+                                ensureCloseParen(), ()
+                                listener: endParenthesizedExpression(()
                         listener: handleNonNullAssertExpression(!)
                         listener: beginTypeArguments(<)
                         listener: handleIdentifier(int, typeReference)
@@ -101,34 +100,33 @@ parseUnit(void)
                       parsePrecedenceExpression(;, 1, true)
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(;)
-                              parseParenthesizedExpression(;)
-                                parseExpressionInParenthesis(;)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(e, expression)
-                                                listener: handleNoTypeArguments(!)
-                                                parseArgumentsOpt(e)
-                                                  listener: handleNoArguments(!)
-                                                listener: handleSend(e, !)
-                                        listener: handleNonNullAssertExpression(!)
-                                        parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
-                                          listener: handleNoTypeArguments(()
-                                          parseArguments(!)
-                                            parseArgumentsRest(()
-                                              listener: beginArguments(()
-                                              listener: endArguments(0, (, ))
-                                          listener: handleSend((, ))
-                                        listener: handleNonNullAssertExpression(!)
-                                    ensureCloseParen(!, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                              parseParenthesizedExpressionOrRecordLiteral(;)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(e, expression)
+                                            listener: handleNoTypeArguments(!)
+                                            parseArgumentsOpt(e)
+                                              listener: handleNoArguments(!)
+                                            listener: handleSend(e, !)
+                                    listener: handleNonNullAssertExpression(!)
+                                    parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
+                                      listener: handleNoTypeArguments(()
+                                      parseArguments(!)
+                                        parseArgumentsRest(()
+                                          listener: beginArguments(()
+                                          listener: endArguments(0, (, ))
+                                      listener: handleSend((, ))
+                                    listener: handleNonNullAssertExpression(!)
+                                ensureCloseParen(!, ()
+                                listener: endParenthesizedExpression(()
                         listener: beginTypeArguments(<)
                         listener: handleIdentifier(int, typeReference)
                         listener: handleNoTypeArguments(>)

pkg/front_end/parser_testcases/nnbd/chained_call_06.dart.expect

@@ -19,18 +19,19 @@ beginCompilationUnit(void)
       endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
       handleAsyncModifier(null, null)
       beginBlockFunctionBody({)
-        handleIdentifier(e, expression)
-        handleNoTypeArguments(!)
-        handleNoArguments(!)
-        handleSend(e, !)
-        handleNonNullAssertExpression(!)
-        handleIdentifier(f, expressionContinuation)
-        handleNoTypeArguments(()
-        beginArguments(()
-        endArguments(0, (, ))
-        handleSend(f, ))
-        handleEndingBinaryExpression(.)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(e, expression)
+          handleNoTypeArguments(!)
+          handleNoArguments(!)
+          handleSend(e, !)
+          handleNonNullAssertExpression(!)
+          handleIdentifier(f, expressionContinuation)
+          handleNoTypeArguments(()
+          beginArguments(()
+          endArguments(0, (, ))
+          handleSend(f, ))
+          handleEndingBinaryExpression(.)
+        endParenthesizedExpression(()
         handleNonNullAssertExpression(!)
         beginTypeArguments(<)
           handleIdentifier(int, typeReference)
@@ -41,19 +42,20 @@ beginCompilationUnit(void)
         endArguments(0, (, ))
         handleSend((, ))
         handleExpressionStatement(;)
-        handleIdentifier(e, expression)
-        handleNoTypeArguments(!)
-        handleNoArguments(!)
-        handleSend(e, !)
-        handleNonNullAssertExpression(!)
-        handleIdentifier(f, expressionContinuation)
-        handleNoTypeArguments(()
-        beginArguments(()
-        endArguments(0, (, ))
-        handleSend(f, !)
-        handleEndingBinaryExpression(.)
-        handleNonNullAssertExpression(!)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(e, expression)
+          handleNoTypeArguments(!)
+          handleNoArguments(!)
+          handleSend(e, !)
+          handleNonNullAssertExpression(!)
+          handleIdentifier(f, expressionContinuation)
+          handleNoTypeArguments(()
+          beginArguments(()
+          endArguments(0, (, ))
+          handleSend(f, !)
+          handleEndingBinaryExpression(.)
+          handleNonNullAssertExpression(!)
+        endParenthesizedExpression(()
         beginTypeArguments(<)
           handleIdentifier(int, typeReference)
           handleNoTypeArguments(>)

pkg/front_end/parser_testcases/nnbd/chained_call_06.dart.intertwined.expect

@@ -48,41 +48,40 @@ parseUnit(void)
                       parsePrecedenceExpression({, 1, true)
                         parseUnaryExpression({, true)
                           parsePrimary({, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral({)
-                              parseParenthesizedExpression({)
-                                parseExpressionInParenthesis({)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(e, expression)
-                                                listener: handleNoTypeArguments(!)
-                                                parseArgumentsOpt(e)
-                                                  listener: handleNoArguments(!)
-                                                listener: handleSend(e, !)
-                                        listener: handleNonNullAssertExpression(!)
-                                        parsePrimary(., expressionContinuation)
-                                          parseSendOrFunctionLiteral(., expressionContinuation)
-                                            looksLikeFunctionBody())
-                                            parseSend(., expressionContinuation)
-                                              isNextIdentifier(.)
-                                              ensureIdentifier(., expressionContinuation)
-                                                listener: handleIdentifier(f, expressionContinuation)
-                                              listener: handleNoTypeArguments(()
-                                              parseArgumentsOpt(f)
-                                                parseArguments(f)
-                                                  parseArgumentsRest(()
-                                                    listener: beginArguments(()
-                                                    listener: endArguments(0, (, ))
-                                              listener: handleSend(f, ))
-                                        listener: handleEndingBinaryExpression(.)
-                                    ensureCloseParen(), ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
+                              parseParenthesizedExpressionOrRecordLiteral({)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(e, expression)
+                                            listener: handleNoTypeArguments(!)
+                                            parseArgumentsOpt(e)
+                                              listener: handleNoArguments(!)
+                                            listener: handleSend(e, !)
+                                    listener: handleNonNullAssertExpression(!)
+                                    parsePrimary(., expressionContinuation)
+                                      parseSendOrFunctionLiteral(., expressionContinuation)
+                                        looksLikeFunctionBody())
+                                        parseSend(., expressionContinuation)
+                                          isNextIdentifier(.)
+                                          ensureIdentifier(., expressionContinuation)
+                                            listener: handleIdentifier(f, expressionContinuation)
+                                          listener: handleNoTypeArguments(()
+                                          parseArgumentsOpt(f)
+                                            parseArguments(f)
+                                              parseArgumentsRest(()
+                                                listener: beginArguments(()
+                                                listener: endArguments(0, (, ))
+                                          listener: handleSend(f, ))
+                                    listener: handleEndingBinaryExpression(.)
+                                ensureCloseParen(), ()
+                                listener: endParenthesizedExpression(()
                         listener: handleNonNullAssertExpression(!)
                         listener: beginTypeArguments(<)
                         listener: handleIdentifier(int, typeReference)
@@ -108,42 +107,41 @@ parseUnit(void)
                       parsePrecedenceExpression(;, 1, true)
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(;)
-                              parseParenthesizedExpression(;)
-                                parseExpressionInParenthesis(;)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(e, expression)
-                                                listener: handleNoTypeArguments(!)
-                                                parseArgumentsOpt(e)
-                                                  listener: handleNoArguments(!)
-                                                listener: handleSend(e, !)
-                                        listener: handleNonNullAssertExpression(!)
-                                        parsePrimary(., expressionContinuation)
-                                          parseSendOrFunctionLiteral(., expressionContinuation)
-                                            looksLikeFunctionBody(!)
-                                            parseSend(., expressionContinuation)
-                                              isNextIdentifier(.)
-                                              ensureIdentifier(., expressionContinuation)
-                                                listener: handleIdentifier(f, expressionContinuation)
-                                              listener: handleNoTypeArguments(()
-                                              parseArgumentsOpt(f)
-                                                parseArguments(f)
-                                                  parseArgumentsRest(()
-                                                    listener: beginArguments(()
-                                                    listener: endArguments(0, (, ))
-                                              listener: handleSend(f, !)
-                                        listener: handleEndingBinaryExpression(.)
-                                        listener: handleNonNullAssertExpression(!)
-                                    ensureCloseParen(!, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                              parseParenthesizedExpressionOrRecordLiteral(;)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(e, expression)
+                                            listener: handleNoTypeArguments(!)
+                                            parseArgumentsOpt(e)
+                                              listener: handleNoArguments(!)
+                                            listener: handleSend(e, !)
+                                    listener: handleNonNullAssertExpression(!)
+                                    parsePrimary(., expressionContinuation)
+                                      parseSendOrFunctionLiteral(., expressionContinuation)
+                                        looksLikeFunctionBody(!)
+                                        parseSend(., expressionContinuation)
+                                          isNextIdentifier(.)
+                                          ensureIdentifier(., expressionContinuation)
+                                            listener: handleIdentifier(f, expressionContinuation)
+                                          listener: handleNoTypeArguments(()
+                                          parseArgumentsOpt(f)
+                                            parseArguments(f)
+                                              parseArgumentsRest(()
+                                                listener: beginArguments(()
+                                                listener: endArguments(0, (, ))
+                                          listener: handleSend(f, !)
+                                    listener: handleEndingBinaryExpression(.)
+                                    listener: handleNonNullAssertExpression(!)
+                                ensureCloseParen(!, ()
+                                listener: endParenthesizedExpression(()
                         listener: beginTypeArguments(<)
                         listener: handleIdentifier(int, typeReference)
                         listener: handleNoTypeArguments(>)

pkg/front_end/parser_testcases/nnbd/issue_39697_prime.dart.expect

@@ -10,27 +10,28 @@ beginCompilationUnit(Logger)
       handleNoTypeVariables(=>)
       handleNoFormalParameters(=>, MemberKind.TopLevelMethod)
       handleAsyncModifier(null, null)
-      handleIdentifier(Zone, expression)
-      handleNoTypeArguments(.)
-      handleNoArguments(.)
-      handleSend(Zone, .)
-      handleIdentifier(current, expressionContinuation)
-      handleNoTypeArguments([)
-      handleNoArguments([)
-      handleSend(current, [)
-      handleEndingBinaryExpression(.)
-      handleIdentifier(logKey, expression)
-      handleNoTypeArguments(])
-      handleNoArguments(])
-      handleSend(logKey, ])
-      handleIndexedExpression(null, [, ])
-      beginAsOperatorType(as)
-        handleIdentifier(Logger, typeReference)
-        handleNoTypeArguments(?)
-        handleType(Logger, ?)
-      endAsOperatorType(as)
-      handleAsOperator(as)
-      handleParenthesizedExpression(()
+      beginParenthesizedExpressionOrRecordLiteral(()
+        handleIdentifier(Zone, expression)
+        handleNoTypeArguments(.)
+        handleNoArguments(.)
+        handleSend(Zone, .)
+        handleIdentifier(current, expressionContinuation)
+        handleNoTypeArguments([)
+        handleNoArguments([)
+        handleSend(current, [)
+        handleEndingBinaryExpression(.)
+        handleIdentifier(logKey, expression)
+        handleNoTypeArguments(])
+        handleNoArguments(])
+        handleSend(logKey, ])
+        handleIndexedExpression(null, [, ])
+        beginAsOperatorType(as)
+          handleIdentifier(Logger, typeReference)
+          handleNoTypeArguments(?)
+          handleType(Logger, ?)
+        endAsOperatorType(as)
+        handleAsOperator(as)
+      endParenthesizedExpression(()
       beginBinaryExpression(??)
         handleIdentifier(_default, expression)
         handleNoTypeArguments(;)

pkg/front_end/parser_testcases/nnbd/issue_39697_prime.dart.intertwined.expect

@@ -28,60 +28,59 @@ parseUnit(Logger)
               parsePrecedenceExpression(=>, 1, true)
                 parseUnaryExpression(=>, true)
                   parsePrimary(=>, expression)
-                    parseParenthesizedExpressionOrFunctionLiteral(=>)
-                      parseParenthesizedExpression(=>)
-                        parseExpressionInParenthesis(=>)
-                          parseExpressionInParenthesisRest(()
-                            parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
-                                    parseSendOrFunctionLiteral((, expression)
-                                      parseSend((, expression)
-                                        isNextIdentifier(()
-                                        ensureIdentifier((, expression)
-                                          listener: handleIdentifier(Zone, expression)
-                                        listener: handleNoTypeArguments(.)
-                                        parseArgumentsOpt(Zone)
-                                          listener: handleNoArguments(.)
-                                        listener: handleSend(Zone, .)
-                                parsePrimary(., expressionContinuation)
-                                  parseSendOrFunctionLiteral(., expressionContinuation)
-                                    parseSend(., expressionContinuation)
-                                      isNextIdentifier(.)
-                                      ensureIdentifier(., expressionContinuation)
-                                        listener: handleIdentifier(current, expressionContinuation)
-                                      listener: handleNoTypeArguments([)
-                                      parseArgumentsOpt(current)
-                                        listener: handleNoArguments([)
-                                      listener: handleSend(current, [)
-                                listener: handleEndingBinaryExpression(.)
-                                parseArgumentOrIndexStar(current, Instance of 'NoTypeParamOrArg', false)
-                                  parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
-                                          parseSendOrFunctionLiteral([, expression)
-                                            parseSend([, expression)
-                                              isNextIdentifier([)
-                                              ensureIdentifier([, expression)
-                                                listener: handleIdentifier(logKey, expression)
-                                              listener: handleNoTypeArguments(])
-                                              parseArgumentsOpt(logKey)
-                                                listener: handleNoArguments(])
-                                              listener: handleSend(logKey, ])
-                                  listener: handleIndexedExpression(null, [, ])
-                                parseAsOperatorRest(])
-                                  listener: beginAsOperatorType(as)
-                                  computeTypeAfterIsOrAs(as)
-                                  listener: handleIdentifier(Logger, typeReference)
-                                  listener: handleNoTypeArguments(?)
-                                  listener: handleType(Logger, ?)
-                                  listener: endAsOperatorType(as)
-                                  listener: handleAsOperator(as)
-                                  skipChainedAsIsOperators(?)
-                            ensureCloseParen(?, ()
-                        listener: handleParenthesizedExpression(()
+                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
+                      parseParenthesizedExpressionOrRecordLiteral(=>)
+                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                        parseExpression(()
+                          parsePrecedenceExpression((, 1, true)
+                            parseUnaryExpression((, true)
+                              parsePrimary((, expression)
+                                parseSendOrFunctionLiteral((, expression)
+                                  parseSend((, expression)
+                                    isNextIdentifier(()
+                                    ensureIdentifier((, expression)
+                                      listener: handleIdentifier(Zone, expression)
+                                    listener: handleNoTypeArguments(.)
+                                    parseArgumentsOpt(Zone)
+                                      listener: handleNoArguments(.)
+                                    listener: handleSend(Zone, .)
+                            parsePrimary(., expressionContinuation)
+                              parseSendOrFunctionLiteral(., expressionContinuation)
+                                parseSend(., expressionContinuation)
+                                  isNextIdentifier(.)
+                                  ensureIdentifier(., expressionContinuation)
+                                    listener: handleIdentifier(current, expressionContinuation)
+                                  listener: handleNoTypeArguments([)
+                                  parseArgumentsOpt(current)
+                                    listener: handleNoArguments([)
+                                  listener: handleSend(current, [)
+                            listener: handleEndingBinaryExpression(.)
+                            parseArgumentOrIndexStar(current, Instance of 'NoTypeParamOrArg', false)
+                              parseExpression([)
+                                parsePrecedenceExpression([, 1, true)
+                                  parseUnaryExpression([, true)
+                                    parsePrimary([, expression)
+                                      parseSendOrFunctionLiteral([, expression)
+                                        parseSend([, expression)
+                                          isNextIdentifier([)
+                                          ensureIdentifier([, expression)
+                                            listener: handleIdentifier(logKey, expression)
+                                          listener: handleNoTypeArguments(])
+                                          parseArgumentsOpt(logKey)
+                                            listener: handleNoArguments(])
+                                          listener: handleSend(logKey, ])
+                              listener: handleIndexedExpression(null, [, ])
+                            parseAsOperatorRest(])
+                              listener: beginAsOperatorType(as)
+                              computeTypeAfterIsOrAs(as)
+                              listener: handleIdentifier(Logger, typeReference)
+                              listener: handleNoTypeArguments(?)
+                              listener: handleType(Logger, ?)
+                              listener: endAsOperatorType(as)
+                              listener: handleAsOperator(as)
+                              skipChainedAsIsOperators(?)
+                        ensureCloseParen(?, ()
+                        listener: endParenthesizedExpression(()
                 listener: beginBinaryExpression(??)
                 parsePrecedenceExpression(??, 5, true)
                   parseUnaryExpression(??, true)

pkg/front_end/parser_testcases/nnbd/issue_39723_prime.dart.expect

@@ -65,12 +65,13 @@ beginCompilationUnit(class)
             endVariableInitializer(=)
           endInitializedIdentifier(a)
         endVariablesDeclaration(1, ;)
-        handleIdentifier(a, expression)
-        handleNoTypeArguments(!)
-        handleNoArguments(!)
-        handleSend(a, !)
-        handleNonNullAssertExpression(!)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(!)
+          handleNoArguments(!)
+          handleSend(a, !)
+          handleNonNullAssertExpression(!)
+        endParenthesizedExpression(()
         handleIdentifier(toString, expressionContinuation)
         handleNoTypeArguments(()
         beginArguments(()
@@ -78,32 +79,35 @@ beginCompilationUnit(class)
         handleSend(toString, ;)
         handleEndingBinaryExpression(?.)
         handleExpressionStatement(;)
-        handleIdentifier(a, expression)
-        handleNoTypeArguments(!)
-        handleNoArguments(!)
-        handleSend(a, !)
-        handleNonNullAssertExpression(!)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(!)
+          handleNoArguments(!)
+          handleSend(a, !)
+          handleNonNullAssertExpression(!)
+        endParenthesizedExpression(()
         handleNoTypeArguments([)
         handleLiteralInt(42)
         handleLiteralList(1, [, null, ])
         handleEndingBinaryExpression(?.)
         handleExpressionStatement(;)
-        handleIdentifier(a, expression)
-        handleNoTypeArguments(!)
-        handleNoArguments(!)
-        handleSend(a, !)
-        handleNonNullAssertExpression(!)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(!)
+          handleNoArguments(!)
+          handleSend(a, !)
+          handleNonNullAssertExpression(!)
+        endParenthesizedExpression(()
         handleLiteralInt(42)
         handleIndexedExpression(?, [, ])
         handleExpressionStatement(;)
-        handleIdentifier(a, expression)
-        handleNoTypeArguments(!)
-        handleNoArguments(!)
-        handleSend(a, !)
-        handleNonNullAssertExpression(!)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(!)
+          handleNoArguments(!)
+          handleSend(a, !)
+          handleNonNullAssertExpression(!)
+        endParenthesizedExpression(()
         handleLiteralInt(42)
         handleIndexedExpression(?, [, ])
         handleExpressionStatement(;)

pkg/front_end/parser_testcases/nnbd/issue_39723_prime.dart.intertwined.expect

@@ -153,26 +153,25 @@ parseUnit(class)
                       parsePrecedenceExpression(;, 1, true)
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(;)
-                              parseParenthesizedExpression(;)
-                                parseExpressionInParenthesis(;)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(a, expression)
-                                                listener: handleNoTypeArguments(!)
-                                                parseArgumentsOpt(a)
-                                                  listener: handleNoArguments(!)
-                                                listener: handleSend(a, !)
-                                        listener: handleNonNullAssertExpression(!)
-                                    ensureCloseParen(!, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                              parseParenthesizedExpressionOrRecordLiteral(;)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(a, expression)
+                                            listener: handleNoTypeArguments(!)
+                                            parseArgumentsOpt(a)
+                                              listener: handleNoArguments(!)
+                                            listener: handleSend(a, !)
+                                    listener: handleNonNullAssertExpression(!)
+                                ensureCloseParen(!, ()
+                                listener: endParenthesizedExpression(()
                         parsePrimary(?., expressionContinuation)
                           parseSendOrFunctionLiteral(?., expressionContinuation)
                             looksLikeFunctionBody(;)
@@ -201,26 +200,25 @@ parseUnit(class)
                       parsePrecedenceExpression(;, 1, true)
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(;)
-                              parseParenthesizedExpression(;)
-                                parseExpressionInParenthesis(;)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(a, expression)
-                                                listener: handleNoTypeArguments(!)
-                                                parseArgumentsOpt(a)
-                                                  listener: handleNoArguments(!)
-                                                listener: handleSend(a, !)
-                                        listener: handleNonNullAssertExpression(!)
-                                    ensureCloseParen(!, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                              parseParenthesizedExpressionOrRecordLiteral(;)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(a, expression)
+                                            listener: handleNoTypeArguments(!)
+                                            parseArgumentsOpt(a)
+                                              listener: handleNoArguments(!)
+                                            listener: handleSend(a, !)
+                                    listener: handleNonNullAssertExpression(!)
+                                ensureCloseParen(!, ()
+                                listener: endParenthesizedExpression(()
                         parsePrimary(?., expressionContinuation)
                           listener: handleNoTypeArguments([)
                           parseLiteralListSuffix(?., null)
@@ -245,26 +243,25 @@ parseUnit(class)
                       parsePrecedenceExpression(;, 1, true)
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(;)
-                              parseParenthesizedExpression(;)
-                                parseExpressionInParenthesis(;)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(a, expression)
-                                                listener: handleNoTypeArguments(!)
-                                                parseArgumentsOpt(a)
-                                                  listener: handleNoArguments(!)
-                                                listener: handleSend(a, !)
-                                        listener: handleNonNullAssertExpression(!)
-                                    ensureCloseParen(!, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                              parseParenthesizedExpressionOrRecordLiteral(;)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(a, expression)
+                                            listener: handleNoTypeArguments(!)
+                                            parseArgumentsOpt(a)
+                                              listener: handleNoArguments(!)
+                                            listener: handleSend(a, !)
+                                    listener: handleNonNullAssertExpression(!)
+                                ensureCloseParen(!, ()
+                                listener: endParenthesizedExpression(()
                         canParseAsConditional(?)
                           parseExpressionWithoutCascade(?)
                             parsePrecedenceExpression(?, 1, false)
@@ -297,26 +294,25 @@ parseUnit(class)
                       parsePrecedenceExpression(;, 1, true)
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(;)
-                              parseParenthesizedExpression(;)
-                                parseExpressionInParenthesis(;)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(a, expression)
-                                                listener: handleNoTypeArguments(!)
-                                                parseArgumentsOpt(a)
-                                                  listener: handleNoArguments(!)
-                                                listener: handleSend(a, !)
-                                        listener: handleNonNullAssertExpression(!)
-                                    ensureCloseParen(!, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                              parseParenthesizedExpressionOrRecordLiteral(;)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(a, expression)
+                                            listener: handleNoTypeArguments(!)
+                                            parseArgumentsOpt(a)
+                                              listener: handleNoArguments(!)
+                                            listener: handleSend(a, !)
+                                    listener: handleNonNullAssertExpression(!)
+                                ensureCloseParen(!, ()
+                                listener: endParenthesizedExpression(()
                         canParseAsConditional(?)
                           parseExpressionWithoutCascade(?)
                             parsePrecedenceExpression(?, 1, false)

pkg/front_end/parser_testcases/nnbd/issue_39776_prime2.dart.expect

@@ -112,12 +112,13 @@ beginCompilationUnit(Object)
             endVariableInitializer(=)
           endInitializedIdentifier(f2)
         endVariablesDeclaration(1, ;)
-        handleIdentifier(f2, expression)
-        handleNoTypeArguments(!)
-        handleNoArguments(!)
-        handleSend(f2, !)
-        handleNonNullAssertExpression(!)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(f2, expression)
+          handleNoTypeArguments(!)
+          handleNoArguments(!)
+          handleSend(f2, !)
+          handleNonNullAssertExpression(!)
+        endParenthesizedExpression(()
         beginTypeArguments(<)
           handleIdentifier(int, typeReference)
           handleNoTypeArguments(>)

pkg/front_end/parser_testcases/nnbd/issue_39776_prime2.dart.intertwined.expect

@@ -259,26 +259,25 @@ parseUnit(Object)
                       parsePrecedenceExpression(;, 1, true)
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(;)
-                              parseParenthesizedExpression(;)
-                                parseExpressionInParenthesis(;)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(f2, expression)
-                                                listener: handleNoTypeArguments(!)
-                                                parseArgumentsOpt(f2)
-                                                  listener: handleNoArguments(!)
-                                                listener: handleSend(f2, !)
-                                        listener: handleNonNullAssertExpression(!)
-                                    ensureCloseParen(!, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                              parseParenthesizedExpressionOrRecordLiteral(;)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(f2, expression)
+                                            listener: handleNoTypeArguments(!)
+                                            parseArgumentsOpt(f2)
+                                              listener: handleNoArguments(!)
+                                            listener: handleSend(f2, !)
+                                    listener: handleNonNullAssertExpression(!)
+                                ensureCloseParen(!, ()
+                                listener: endParenthesizedExpression(()
                         listener: beginTypeArguments(<)
                         listener: handleIdentifier(int, typeReference)
                         listener: handleNoTypeArguments(>)

pkg/front_end/parser_testcases/nnbd/issue_40267_conditional.dart.expect

@@ -144,21 +144,23 @@ beginCompilationUnit(f)
         handleNoArguments(?)
         handleSend(a, ?)
         beginConditionalExpression(?)
-          handleNoTypeArguments([)
-          handleIdentifier(b, expression)
-          handleNoTypeArguments(])
-          handleNoArguments(])
-          handleSend(b, ])
-          handleLiteralList(1, [, null, ])
-          handleParenthesizedExpression(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleNoTypeArguments([)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(])
+            handleNoArguments(])
+            handleSend(b, ])
+            handleLiteralList(1, [, null, ])
+          endParenthesizedExpression(()
           handleConditionalExpressionColon()
-          handleNoTypeArguments([)
-          handleIdentifier(c, expression)
-          handleNoTypeArguments(])
-          handleNoArguments(])
-          handleSend(c, ])
-          handleLiteralList(1, [, null, ])
-          handleParenthesizedExpression(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleNoTypeArguments([)
+            handleIdentifier(c, expression)
+            handleNoTypeArguments(])
+            handleNoArguments(])
+            handleSend(c, ])
+            handleLiteralList(1, [, null, ])
+          endParenthesizedExpression(()
         endConditionalExpression(?, :)
         handleExpressionStatement(;)
       endBlockFunctionBody(7, {, })

pkg/front_end/parser_testcases/nnbd/issue_40267_conditional.dart.intertwined.expect

@@ -540,64 +540,62 @@ parseUnit(f)
                           parsePrecedenceExpression(?, 1, false)
                             parseUnaryExpression(?, false)
                               parsePrimary(?, expression)
-                                parseParenthesizedExpressionOrFunctionLiteral(?)
-                                  parseParenthesizedExpression(?)
-                                    parseExpressionInParenthesis(?)
-                                      parseExpressionInParenthesisRest(()
-                                        parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
-                                                listener: handleNoTypeArguments([)
-                                                parseLiteralListSuffix((, null)
-                                                  parseExpression([)
-                                                    parsePrecedenceExpression([, 1, true)
-                                                      parseUnaryExpression([, true)
-                                                        parsePrimary([, expression)
-                                                          parseSendOrFunctionLiteral([, expression)
-                                                            parseSend([, expression)
-                                                              isNextIdentifier([)
-                                                              ensureIdentifier([, expression)
-                                                                listener: handleIdentifier(b, expression)
-                                                              listener: handleNoTypeArguments(])
-                                                              parseArgumentsOpt(b)
-                                                                listener: handleNoArguments(])
-                                                              listener: handleSend(b, ])
-                                                  listener: handleLiteralList(1, [, null, ])
-                                        ensureCloseParen(], ()
-                                    listener: handleParenthesizedExpression(()
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(?)
+                                  parseParenthesizedExpressionOrRecordLiteral(?)
+                                    listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                    parseExpression(()
+                                      parsePrecedenceExpression((, 1, true)
+                                        parseUnaryExpression((, true)
+                                          parsePrimary((, expression)
+                                            listener: handleNoTypeArguments([)
+                                            parseLiteralListSuffix((, null)
+                                              parseExpression([)
+                                                parsePrecedenceExpression([, 1, true)
+                                                  parseUnaryExpression([, true)
+                                                    parsePrimary([, expression)
+                                                      parseSendOrFunctionLiteral([, expression)
+                                                        parseSend([, expression)
+                                                          isNextIdentifier([)
+                                                          ensureIdentifier([, expression)
+                                                            listener: handleIdentifier(b, expression)
+                                                          listener: handleNoTypeArguments(])
+                                                          parseArgumentsOpt(b)
+                                                            listener: handleNoArguments(])
+                                                          listener: handleSend(b, ])
+                                              listener: handleLiteralList(1, [, null, ])
+                                    ensureCloseParen(], ()
+                                    listener: endParenthesizedExpression(()
                         ensureColon())
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
                           parsePrecedenceExpression(:, 1, false)
                             parseUnaryExpression(:, false)
                               parsePrimary(:, expression)
-                                parseParenthesizedExpressionOrFunctionLiteral(:)
-                                  parseParenthesizedExpression(:)
-                                    parseExpressionInParenthesis(:)
-                                      parseExpressionInParenthesisRest(()
-                                        parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
-                                                listener: handleNoTypeArguments([)
-                                                parseLiteralListSuffix((, null)
-                                                  parseExpression([)
-                                                    parsePrecedenceExpression([, 1, true)
-                                                      parseUnaryExpression([, true)
-                                                        parsePrimary([, expression)
-                                                          parseSendOrFunctionLiteral([, expression)
-                                                            parseSend([, expression)
-                                                              isNextIdentifier([)
-                                                              ensureIdentifier([, expression)
-                                                                listener: handleIdentifier(c, expression)
-                                                              listener: handleNoTypeArguments(])
-                                                              parseArgumentsOpt(c)
-                                                                listener: handleNoArguments(])
-                                                              listener: handleSend(c, ])
-                                                  listener: handleLiteralList(1, [, null, ])
-                                        ensureCloseParen(], ()
-                                    listener: handleParenthesizedExpression(()
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:)
+                                  parseParenthesizedExpressionOrRecordLiteral(:)
+                                    listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                    parseExpression(()
+                                      parsePrecedenceExpression((, 1, true)
+                                        parseUnaryExpression((, true)
+                                          parsePrimary((, expression)
+                                            listener: handleNoTypeArguments([)
+                                            parseLiteralListSuffix((, null)
+                                              parseExpression([)
+                                                parsePrecedenceExpression([, 1, true)
+                                                  parseUnaryExpression([, true)
+                                                    parsePrimary([, expression)
+                                                      parseSendOrFunctionLiteral([, expression)
+                                                        parseSend([, expression)
+                                                          isNextIdentifier([)
+                                                          ensureIdentifier([, expression)
+                                                            listener: handleIdentifier(c, expression)
+                                                          listener: handleNoTypeArguments(])
+                                                          parseArgumentsOpt(c)
+                                                            listener: handleNoArguments(])
+                                                          listener: handleSend(c, ])
+                                              listener: handleLiteralList(1, [, null, ])
+                                    ensureCloseParen(], ()
+                                    listener: endParenthesizedExpression(()
                         listener: endConditionalExpression(?, :)
                   ensureSemicolon())
                   listener: handleExpressionStatement(;)

pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_no_type_arguments.dart.expect

@@ -53,11 +53,12 @@ beginCompilationUnit(f)
         handleNoArguments(?)
         handleSend(a, ?)
         beginConditionalExpression(?)
-          handleIdentifier(b, expression)
-          handleNoTypeArguments())
-          handleNoArguments())
-          handleSend(b, ))
-          handleParenthesizedExpression(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleIdentifier(b, expression)
+            handleNoTypeArguments())
+            handleNoArguments())
+            handleSend(b, ))
+          endParenthesizedExpression(()
           handleRecoverableError(Message[ExpectedButGot, Expected ':' before this., null, {string: :}], ;, ;)
           handleConditionalExpressionColon()
           handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ';'., Try inserting an identifier before ';'., {lexeme: ;}], ;, ;)

pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_no_type_arguments.dart.intertwined.expect

@@ -126,25 +126,24 @@ parseUnit(f)
                           parsePrecedenceExpression(?, 1, false)
                             parseUnaryExpression(?, false)
                               parsePrimary(?, expression)
-                                parseParenthesizedExpressionOrFunctionLiteral(?)
-                                  parseParenthesizedExpression(?)
-                                    parseExpressionInParenthesis(?)
-                                      parseExpressionInParenthesisRest(()
-                                        parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
-                                                parseSendOrFunctionLiteral((, expression)
-                                                  parseSend((, expression)
-                                                    isNextIdentifier(()
-                                                    ensureIdentifier((, expression)
-                                                      listener: handleIdentifier(b, expression)
-                                                    listener: handleNoTypeArguments())
-                                                    parseArgumentsOpt(b)
-                                                      listener: handleNoArguments())
-                                                    listener: handleSend(b, ))
-                                        ensureCloseParen(b, ()
-                                    listener: handleParenthesizedExpression(()
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(?)
+                                  parseParenthesizedExpressionOrRecordLiteral(?)
+                                    listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                    parseExpression(()
+                                      parsePrecedenceExpression((, 1, true)
+                                        parseUnaryExpression((, true)
+                                          parsePrimary((, expression)
+                                            parseSendOrFunctionLiteral((, expression)
+                                              parseSend((, expression)
+                                                isNextIdentifier(()
+                                                ensureIdentifier((, expression)
+                                                  listener: handleIdentifier(b, expression)
+                                                listener: handleNoTypeArguments())
+                                                parseArgumentsOpt(b)
+                                                  listener: handleNoArguments())
+                                                listener: handleSend(b, ))
+                                    ensureCloseParen(b, ()
+                                    listener: endParenthesizedExpression(()
                         ensureColon())
                           rewriteAndRecover(), Message[ExpectedButGot, Expected ':' before this., null, {string: :}], :)
                             reportRecoverableError(;, Message[ExpectedButGot, Expected ':' before this., null, {string: :}])

pkg/front_end/parser_testcases/nnbd/issue_40793_prime.dart.expect

@@ -20,17 +20,18 @@ beginCompilationUnit(void)
       handleAsyncModifier(null, null)
       beginBlockFunctionBody({)
         beginIfStatement(if)
-          handleIdentifier(sample, expression)
-          handleNoTypeArguments(.)
-          handleNoArguments(.)
-          handleSend(sample, .)
-          handleIdentifier(value, expressionContinuation)
-          handleNoTypeArguments(!)
-          handleNoArguments(!)
-          handleSend(value, !)
-          handleEndingBinaryExpression(.)
-          handleNonNullAssertExpression(!)
-          handleParenthesizedExpression(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleIdentifier(sample, expression)
+            handleNoTypeArguments(.)
+            handleNoArguments(.)
+            handleSend(sample, .)
+            handleIdentifier(value, expressionContinuation)
+            handleNoTypeArguments(!)
+            handleNoArguments(!)
+            handleSend(value, !)
+            handleEndingBinaryExpression(.)
+            handleNonNullAssertExpression(!)
+          endParenthesizedExpression(()
           beginBinaryExpression(<)
             handleLiteralInt(10)
           endBinaryExpression(<)

pkg/front_end/parser_testcases/nnbd/issue_40793_prime.dart.intertwined.expect

@@ -48,37 +48,36 @@ parseUnit(void)
                       parsePrecedenceExpression((, 1, true)
                         parseUnaryExpression((, true)
                           parsePrimary((, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(()
-                              parseParenthesizedExpression(()
-                                parseExpressionInParenthesis(()
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(sample, expression)
-                                                listener: handleNoTypeArguments(.)
-                                                parseArgumentsOpt(sample)
-                                                  listener: handleNoArguments(.)
-                                                listener: handleSend(sample, .)
-                                        parsePrimary(., expressionContinuation)
-                                          parseSendOrFunctionLiteral(., expressionContinuation)
-                                            parseSend(., expressionContinuation)
-                                              isNextIdentifier(.)
-                                              ensureIdentifier(., expressionContinuation)
-                                                listener: handleIdentifier(value, expressionContinuation)
-                                              listener: handleNoTypeArguments(!)
-                                              parseArgumentsOpt(value)
-                                                listener: handleNoArguments(!)
-                                              listener: handleSend(value, !)
-                                        listener: handleEndingBinaryExpression(.)
-                                        listener: handleNonNullAssertExpression(!)
-                                    ensureCloseParen(!, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
+                              parseParenthesizedExpressionOrRecordLiteral(()
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(sample, expression)
+                                            listener: handleNoTypeArguments(.)
+                                            parseArgumentsOpt(sample)
+                                              listener: handleNoArguments(.)
+                                            listener: handleSend(sample, .)
+                                    parsePrimary(., expressionContinuation)
+                                      parseSendOrFunctionLiteral(., expressionContinuation)
+                                        parseSend(., expressionContinuation)
+                                          isNextIdentifier(.)
+                                          ensureIdentifier(., expressionContinuation)
+                                            listener: handleIdentifier(value, expressionContinuation)
+                                          listener: handleNoTypeArguments(!)
+                                          parseArgumentsOpt(value)
+                                            listener: handleNoArguments(!)
+                                          listener: handleSend(value, !)
+                                    listener: handleEndingBinaryExpression(.)
+                                    listener: handleNonNullAssertExpression(!)
+                                ensureCloseParen(!, ()
+                                listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(<)
                         parsePrecedenceExpression(<, 9, true)
                           parseUnaryExpression(<, true)

pkg/front_end/parser_testcases/nnbd/issue_40793_prime2.dart.expect

@@ -20,16 +20,17 @@ beginCompilationUnit(void)
       handleAsyncModifier(null, null)
       beginBlockFunctionBody({)
         beginIfStatement(if)
-          handleIdentifier(sample, expression)
-          handleNoTypeArguments(.)
-          handleNoArguments(.)
-          handleSend(sample, .)
-          handleIdentifier(value, expressionContinuation)
-          handleNoTypeArguments())
-          handleNoArguments())
-          handleSend(value, ))
-          handleEndingBinaryExpression(.)
-          handleParenthesizedExpression(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleIdentifier(sample, expression)
+            handleNoTypeArguments(.)
+            handleNoArguments(.)
+            handleSend(sample, .)
+            handleIdentifier(value, expressionContinuation)
+            handleNoTypeArguments())
+            handleNoArguments())
+            handleSend(value, ))
+            handleEndingBinaryExpression(.)
+          endParenthesizedExpression(()
           beginBinaryExpression(<)
             handleLiteralInt(10)
           endBinaryExpression(<)

pkg/front_end/parser_testcases/nnbd/issue_40793_prime2.dart.intertwined.expect

@@ -48,36 +48,35 @@ parseUnit(void)
                       parsePrecedenceExpression((, 1, true)
                         parseUnaryExpression((, true)
                           parsePrimary((, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(()
-                              parseParenthesizedExpression(()
-                                parseExpressionInParenthesis(()
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(sample, expression)
-                                                listener: handleNoTypeArguments(.)
-                                                parseArgumentsOpt(sample)
-                                                  listener: handleNoArguments(.)
-                                                listener: handleSend(sample, .)
-                                        parsePrimary(., expressionContinuation)
-                                          parseSendOrFunctionLiteral(., expressionContinuation)
-                                            parseSend(., expressionContinuation)
-                                              isNextIdentifier(.)
-                                              ensureIdentifier(., expressionContinuation)
-                                                listener: handleIdentifier(value, expressionContinuation)
-                                              listener: handleNoTypeArguments())
-                                              parseArgumentsOpt(value)
-                                                listener: handleNoArguments())
-                                              listener: handleSend(value, ))
-                                        listener: handleEndingBinaryExpression(.)
-                                    ensureCloseParen(value, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
+                              parseParenthesizedExpressionOrRecordLiteral(()
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(sample, expression)
+                                            listener: handleNoTypeArguments(.)
+                                            parseArgumentsOpt(sample)
+                                              listener: handleNoArguments(.)
+                                            listener: handleSend(sample, .)
+                                    parsePrimary(., expressionContinuation)
+                                      parseSendOrFunctionLiteral(., expressionContinuation)
+                                        parseSend(., expressionContinuation)
+                                          isNextIdentifier(.)
+                                          ensureIdentifier(., expressionContinuation)
+                                            listener: handleIdentifier(value, expressionContinuation)
+                                          listener: handleNoTypeArguments())
+                                          parseArgumentsOpt(value)
+                                            listener: handleNoArguments())
+                                          listener: handleSend(value, ))
+                                    listener: handleEndingBinaryExpression(.)
+                                ensureCloseParen(value, ()
+                                listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(<)
                         parsePrecedenceExpression(<, 9, true)
                           parseUnaryExpression(<, true)

pkg/front_end/parser_testcases/nnbd/issue_41177.dart.expect

@@ -55,12 +55,13 @@ beginCompilationUnit(main)
         handleLiteralInt(0)
         handleIndexedExpression(?, [, ])
         handleExpressionStatement(;)
-        handleIdentifier(a, expression)
-        handleNoTypeArguments(!)
-        handleNoArguments(!)
-        handleSend(a, !)
-        handleNonNullAssertExpression(!)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(!)
+          handleNoArguments(!)
+          handleSend(a, !)
+          handleNonNullAssertExpression(!)
+        endParenthesizedExpression(()
         handleLiteralInt(0)
         handleIndexedExpression(?, [, ])
         handleExpressionStatement(;)
@@ -77,12 +78,13 @@ beginCompilationUnit(main)
           handleLiteralInt(0)
         endConditionalExpression(?, :)
         handleExpressionStatement(;)
-        handleIdentifier(b, expression)
-        handleNoTypeArguments(!)
-        handleNoArguments(!)
-        handleSend(b, !)
-        handleNonNullAssertExpression(!)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(b, expression)
+          handleNoTypeArguments(!)
+          handleNoArguments(!)
+          handleSend(b, !)
+          handleNonNullAssertExpression(!)
+        endParenthesizedExpression(()
         beginConditionalExpression(?)
           handleNoTypeArguments([)
           handleLiteralInt(0)

pkg/front_end/parser_testcases/nnbd/issue_41177.dart.intertwined.expect

@@ -176,26 +176,25 @@ parseUnit(main)
                       parsePrecedenceExpression(;, 1, true)
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(;)
-                              parseParenthesizedExpression(;)
-                                parseExpressionInParenthesis(;)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(a, expression)
-                                                listener: handleNoTypeArguments(!)
-                                                parseArgumentsOpt(a)
-                                                  listener: handleNoArguments(!)
-                                                listener: handleSend(a, !)
-                                        listener: handleNonNullAssertExpression(!)
-                                    ensureCloseParen(!, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                              parseParenthesizedExpressionOrRecordLiteral(;)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(a, expression)
+                                            listener: handleNoTypeArguments(!)
+                                            parseArgumentsOpt(a)
+                                              listener: handleNoArguments(!)
+                                            listener: handleSend(a, !)
+                                    listener: handleNonNullAssertExpression(!)
+                                ensureCloseParen(!, ()
+                                listener: endParenthesizedExpression(()
                         canParseAsConditional(?)
                           parseExpressionWithoutCascade(?)
                             parsePrecedenceExpression(?, 1, false)
@@ -290,26 +289,25 @@ parseUnit(main)
                       parsePrecedenceExpression(;, 1, true)
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral(;)
-                              parseParenthesizedExpression(;)
-                                parseExpressionInParenthesis(;)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(b, expression)
-                                                listener: handleNoTypeArguments(!)
-                                                parseArgumentsOpt(b)
-                                                  listener: handleNoArguments(!)
-                                                listener: handleSend(b, !)
-                                        listener: handleNonNullAssertExpression(!)
-                                    ensureCloseParen(!, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                              parseParenthesizedExpressionOrRecordLiteral(;)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(b, expression)
+                                            listener: handleNoTypeArguments(!)
+                                            parseArgumentsOpt(b)
+                                              listener: handleNoArguments(!)
+                                            listener: handleSend(b, !)
+                                    listener: handleNonNullAssertExpression(!)
+                                ensureCloseParen(!, ()
+                                listener: endParenthesizedExpression(()
                         canParseAsConditional(?)
                           parseExpressionWithoutCascade(?)
                             parsePrecedenceExpression(?, 1, false)

pkg/front_end/parser_testcases/nnbd/issue_42621.dart.expect

@@ -202,20 +202,21 @@ beginCompilationUnit(Order)
             handleNoArguments(=)
             handleSend(x, =)
             handleEndingBinaryExpression(..)
-            handleIdentifier(json, expression)
-            handleNoTypeArguments([)
-            handleNoArguments([)
-            handleSend(json, [)
-            beginLiteralString('x')
-            endLiteralString(0, ])
-            handleIndexedExpression(null, [, ])
-            beginAsOperatorType(as)
-              handleIdentifier(List, typeReference)
-              handleNoTypeArguments(?)
-              handleType(List, ?)
-            endAsOperatorType(as)
-            handleAsOperator(as)
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleIdentifier(json, expression)
+              handleNoTypeArguments([)
+              handleNoArguments([)
+              handleSend(json, [)
+              beginLiteralString('x')
+              endLiteralString(0, ])
+              handleIndexedExpression(null, [, ])
+              beginAsOperatorType(as)
+                handleIdentifier(List, typeReference)
+                handleNoTypeArguments(?)
+                handleType(List, ?)
+              endAsOperatorType(as)
+              handleAsOperator(as)
+            endParenthesizedExpression(()
             handleAssignmentExpression(=)
           endCascade()
           beginCascade(..)

pkg/front_end/parser_testcases/nnbd/issue_42621.dart.intertwined.expect

@@ -417,44 +417,43 @@ parseUnit(Order)
                         parsePrecedenceExpression(=, 1, false)
                           parseUnaryExpression(=, false)
                             parsePrimary(=, expression)
-                              parseParenthesizedExpressionOrFunctionLiteral(=)
-                                parseParenthesizedExpression(=)
-                                  parseExpressionInParenthesis(=)
-                                    parseExpressionInParenthesisRest(()
-                                      parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
-                                              parseSendOrFunctionLiteral((, expression)
-                                                parseSend((, expression)
-                                                  isNextIdentifier(()
-                                                  ensureIdentifier((, expression)
-                                                    listener: handleIdentifier(json, expression)
-                                                  listener: handleNoTypeArguments([)
-                                                  parseArgumentsOpt(json)
-                                                    listener: handleNoArguments([)
-                                                  listener: handleSend(json, [)
-                                          parseArgumentOrIndexStar(json, Instance of 'NoTypeParamOrArg', false)
-                                            parseExpression([)
-                                              parsePrecedenceExpression([, 1, true)
-                                                parseUnaryExpression([, true)
-                                                  parsePrimary([, expression)
-                                                    parseLiteralString([)
-                                                      parseSingleLiteralString([)
-                                                        listener: beginLiteralString('x')
-                                                        listener: endLiteralString(0, ])
-                                            listener: handleIndexedExpression(null, [, ])
-                                          parseAsOperatorRest(])
-                                            listener: beginAsOperatorType(as)
-                                            computeTypeAfterIsOrAs(as)
-                                            listener: handleIdentifier(List, typeReference)
-                                            listener: handleNoTypeArguments(?)
-                                            listener: handleType(List, ?)
-                                            listener: endAsOperatorType(as)
-                                            listener: handleAsOperator(as)
-                                            skipChainedAsIsOperators(?)
-                                      ensureCloseParen(?, ()
-                                  listener: handleParenthesizedExpression(()
+                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                parseParenthesizedExpressionOrRecordLiteral(=)
+                                  listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                  parseExpression(()
+                                    parsePrecedenceExpression((, 1, true)
+                                      parseUnaryExpression((, true)
+                                        parsePrimary((, expression)
+                                          parseSendOrFunctionLiteral((, expression)
+                                            parseSend((, expression)
+                                              isNextIdentifier(()
+                                              ensureIdentifier((, expression)
+                                                listener: handleIdentifier(json, expression)
+                                              listener: handleNoTypeArguments([)
+                                              parseArgumentsOpt(json)
+                                                listener: handleNoArguments([)
+                                              listener: handleSend(json, [)
+                                      parseArgumentOrIndexStar(json, Instance of 'NoTypeParamOrArg', false)
+                                        parseExpression([)
+                                          parsePrecedenceExpression([, 1, true)
+                                            parseUnaryExpression([, true)
+                                              parsePrimary([, expression)
+                                                parseLiteralString([)
+                                                  parseSingleLiteralString([)
+                                                    listener: beginLiteralString('x')
+                                                    listener: endLiteralString(0, ])
+                                        listener: handleIndexedExpression(null, [, ])
+                                      parseAsOperatorRest(])
+                                        listener: beginAsOperatorType(as)
+                                        computeTypeAfterIsOrAs(as)
+                                        listener: handleIdentifier(List, typeReference)
+                                        listener: handleNoTypeArguments(?)
+                                        listener: handleType(List, ?)
+                                        listener: endAsOperatorType(as)
+                                        listener: handleAsOperator(as)
+                                        skipChainedAsIsOperators(?)
+                                  ensureCloseParen(?, ()
+                                  listener: endParenthesizedExpression(()
                       listener: handleAssignmentExpression(=)
                       listener: endCascade()
                     parseCascadeExpression())

pkg/front_end/parser_testcases/nnbd/issue_47020.dart.intertwined.expect

@@ -35,7 +35,7 @@ parseUnit(void)
                     parsePrecedenceExpression(=, 1, false)
                       parseUnaryExpression(=, false)
                         parsePrimary(=, expression)
-                          parseParenthesizedExpressionOrFunctionLiteral(=)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
                             parseFunctionExpression(=)
                               parseFormalParametersRequiredOpt(=, MemberKind.Local)
                                 parseFormalParametersRest((, MemberKind.Local)
@@ -87,7 +87,7 @@ parseUnit(void)
                           parsePrecedenceExpression(=, 1, true)
                             parseUnaryExpression(=, true)
                               parsePrimary(=, expression)
-                                parseParenthesizedExpressionOrFunctionLiteral(=)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
                                   listener: handleNoTypeVariables(()
                                   parseFunctionExpression(=)
                                     listener: beginFunctionExpression(()

pkg/front_end/parser_testcases/nnbd/issue_48999.equivalence_info

@@ -4,4 +4,5 @@ files:
 filters:
   - ignoreListenerArguments
 ignored:
-  - handleParenthesizedExpression
+  - beginParenthesizedExpressionOrRecordLiteral
+  - endParenthesizedExpression

pkg/front_end/parser_testcases/nnbd/issue_48999_prime.dart.expect

@@ -27,17 +27,18 @@ beginCompilationUnit(void)
         handleNoTypeArguments(()
         beginArguments(()
           beginLiteralString(')
-            handleIdentifier(i, expression)
-            handleNoTypeArguments(as)
-            handleNoArguments(as)
-            handleSend(i, as)
-            beginAsOperatorType(as)
-              handleIdentifier(int, typeReference)
-              handleNoTypeArguments(?)
-              handleType(int, ?)
-            endAsOperatorType(as)
-            handleAsOperator(as)
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleIdentifier(i, expression)
+              handleNoTypeArguments(as)
+              handleNoArguments(as)
+              handleSend(i, as)
+              beginAsOperatorType(as)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(?)
+                handleType(int, ?)
+              endAsOperatorType(as)
+              handleAsOperator(as)
+            endParenthesizedExpression(()
             handleInterpolationExpression(${, })
             handleStringPart(')
           endLiteralString(1, ))
@@ -48,17 +49,18 @@ beginCompilationUnit(void)
         handleNoTypeArguments(()
         beginArguments(()
           beginLiteralString(')
-            handleIdentifier(i, expression)
-            handleNoTypeArguments(is)
-            handleNoArguments(is)
-            handleSend(i, is)
-            beginIsOperatorType(is)
-              handleIdentifier(int, typeReference)
-              handleNoTypeArguments(?)
-              handleType(int, ?)
-            endIsOperatorType(is)
-            handleIsOperator(is, null)
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleIdentifier(i, expression)
+              handleNoTypeArguments(is)
+              handleNoArguments(is)
+              handleSend(i, is)
+              beginIsOperatorType(is)
+                handleIdentifier(int, typeReference)
+                handleNoTypeArguments(?)
+                handleType(int, ?)
+              endIsOperatorType(is)
+              handleIsOperator(is, null)
+            endParenthesizedExpression(()
             handleInterpolationExpression(${, })
             handleStringPart(')
           endLiteralString(1, ))

pkg/front_end/parser_testcases/nnbd/issue_48999_prime.dart.intertwined.expect

@@ -86,34 +86,33 @@ parseUnit(void)
                                                   parsePrecedenceExpression(${, 1, true)
                                                     parseUnaryExpression(${, true)
                                                       parsePrimary(${, expression)
-                                                        parseParenthesizedExpressionOrFunctionLiteral(${)
-                                                          parseParenthesizedExpression(${)
-                                                            parseExpressionInParenthesis(${)
-                                                              parseExpressionInParenthesisRest(()
-                                                                parseExpression(()
-                                                                  parsePrecedenceExpression((, 1, true)
-                                                                    parseUnaryExpression((, true)
-                                                                      parsePrimary((, expression)
-                                                                        parseSendOrFunctionLiteral((, expression)
-                                                                          parseSend((, expression)
-                                                                            isNextIdentifier(()
-                                                                            ensureIdentifier((, expression)
-                                                                              listener: handleIdentifier(i, expression)
-                                                                            listener: handleNoTypeArguments(as)
-                                                                            parseArgumentsOpt(i)
-                                                                              listener: handleNoArguments(as)
-                                                                            listener: handleSend(i, as)
-                                                                    parseAsOperatorRest(i)
-                                                                      listener: beginAsOperatorType(as)
-                                                                      computeTypeAfterIsOrAs(as)
-                                                                      listener: handleIdentifier(int, typeReference)
-                                                                      listener: handleNoTypeArguments(?)
-                                                                      listener: handleType(int, ?)
-                                                                      listener: endAsOperatorType(as)
-                                                                      listener: handleAsOperator(as)
-                                                                      skipChainedAsIsOperators(?)
-                                                                ensureCloseParen(?, ()
-                                                            listener: handleParenthesizedExpression(()
+                                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(${)
+                                                          parseParenthesizedExpressionOrRecordLiteral(${)
+                                                            listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                            parseExpression(()
+                                                              parsePrecedenceExpression((, 1, true)
+                                                                parseUnaryExpression((, true)
+                                                                  parsePrimary((, expression)
+                                                                    parseSendOrFunctionLiteral((, expression)
+                                                                      parseSend((, expression)
+                                                                        isNextIdentifier(()
+                                                                        ensureIdentifier((, expression)
+                                                                          listener: handleIdentifier(i, expression)
+                                                                        listener: handleNoTypeArguments(as)
+                                                                        parseArgumentsOpt(i)
+                                                                          listener: handleNoArguments(as)
+                                                                        listener: handleSend(i, as)
+                                                                parseAsOperatorRest(i)
+                                                                  listener: beginAsOperatorType(as)
+                                                                  computeTypeAfterIsOrAs(as)
+                                                                  listener: handleIdentifier(int, typeReference)
+                                                                  listener: handleNoTypeArguments(?)
+                                                                  listener: handleType(int, ?)
+                                                                  listener: endAsOperatorType(as)
+                                                                  listener: handleAsOperator(as)
+                                                                  skipChainedAsIsOperators(?)
+                                                            ensureCloseParen(?, ()
+                                                            listener: endParenthesizedExpression(()
                                                 listener: handleInterpolationExpression(${, })
                                                 parseStringPart(})
                                                   listener: handleStringPart(')
@@ -154,34 +153,33 @@ parseUnit(void)
                                                   parsePrecedenceExpression(${, 1, true)
                                                     parseUnaryExpression(${, true)
                                                       parsePrimary(${, expression)
-                                                        parseParenthesizedExpressionOrFunctionLiteral(${)
-                                                          parseParenthesizedExpression(${)
-                                                            parseExpressionInParenthesis(${)
-                                                              parseExpressionInParenthesisRest(()
-                                                                parseExpression(()
-                                                                  parsePrecedenceExpression((, 1, true)
-                                                                    parseUnaryExpression((, true)
-                                                                      parsePrimary((, expression)
-                                                                        parseSendOrFunctionLiteral((, expression)
-                                                                          parseSend((, expression)
-                                                                            isNextIdentifier(()
-                                                                            ensureIdentifier((, expression)
-                                                                              listener: handleIdentifier(i, expression)
-                                                                            listener: handleNoTypeArguments(is)
-                                                                            parseArgumentsOpt(i)
-                                                                              listener: handleNoArguments(is)
-                                                                            listener: handleSend(i, is)
-                                                                    parseIsOperatorRest(i)
-                                                                      listener: beginIsOperatorType(is)
-                                                                      computeTypeAfterIsOrAs(is)
-                                                                      listener: handleIdentifier(int, typeReference)
-                                                                      listener: handleNoTypeArguments(?)
-                                                                      listener: handleType(int, ?)
-                                                                      listener: endIsOperatorType(is)
-                                                                      listener: handleIsOperator(is, null)
-                                                                      skipChainedAsIsOperators(?)
-                                                                ensureCloseParen(?, ()
-                                                            listener: handleParenthesizedExpression(()
+                                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(${)
+                                                          parseParenthesizedExpressionOrRecordLiteral(${)
+                                                            listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                            parseExpression(()
+                                                              parsePrecedenceExpression((, 1, true)
+                                                                parseUnaryExpression((, true)
+                                                                  parsePrimary((, expression)
+                                                                    parseSendOrFunctionLiteral((, expression)
+                                                                      parseSend((, expression)
+                                                                        isNextIdentifier(()
+                                                                        ensureIdentifier((, expression)
+                                                                          listener: handleIdentifier(i, expression)
+                                                                        listener: handleNoTypeArguments(is)
+                                                                        parseArgumentsOpt(i)
+                                                                          listener: handleNoArguments(is)
+                                                                        listener: handleSend(i, is)
+                                                                parseIsOperatorRest(i)
+                                                                  listener: beginIsOperatorType(is)
+                                                                  computeTypeAfterIsOrAs(is)
+                                                                  listener: handleIdentifier(int, typeReference)
+                                                                  listener: handleNoTypeArguments(?)
+                                                                  listener: handleType(int, ?)
+                                                                  listener: endIsOperatorType(is)
+                                                                  listener: handleIsOperator(is, null)
+                                                                  skipChainedAsIsOperators(?)
+                                                            ensureCloseParen(?, ()
+                                                            listener: endParenthesizedExpression(()
                                                 listener: handleInterpolationExpression(${, })
                                                 parseStringPart(})
                                                   listener: handleStringPart(')

pkg/front_end/parser_testcases/nnbd/issue_49132.equivalence_info

@@ -4,4 +4,5 @@ files:
 filters:
   - ignoreListenerArguments
 ignored:
-  - handleParenthesizedExpression
+  - beginParenthesizedExpressionOrRecordLiteral
+  - endParenthesizedExpression

pkg/front_end/parser_testcases/nnbd/issue_49132_prime.dart.expect

@@ -46,17 +46,18 @@ beginCompilationUnit(class)
                 handleNoTypeArguments(=)
                 handleNoArguments(=)
                 handleSend(x, =)
-                handleIdentifier(a, expression)
-                handleNoTypeArguments(as)
-                handleNoArguments(as)
-                handleSend(a, as)
-                beginAsOperatorType(as)
-                  handleIdentifier(int, typeReference)
-                  handleNoTypeArguments())
-                  handleType(int, null)
-                endAsOperatorType(as)
-                handleAsOperator(as)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(a, expression)
+                  handleNoTypeArguments(as)
+                  handleNoArguments(as)
+                  handleSend(a, as)
+                  beginAsOperatorType(as)
+                    handleIdentifier(int, typeReference)
+                    handleNoTypeArguments())
+                    handleType(int, null)
+                  endAsOperatorType(as)
+                  handleAsOperator(as)
+                endParenthesizedExpression(()
                 handleAssignmentExpression(=)
               endInitializer(,)
               beginInitializer(y)
@@ -64,17 +65,18 @@ beginCompilationUnit(class)
                 handleNoTypeArguments(=)
                 handleNoArguments(=)
                 handleSend(y, =)
-                handleIdentifier(b, expression)
-                handleNoTypeArguments(as)
-                handleNoArguments(as)
-                handleSend(b, as)
-                beginAsOperatorType(as)
-                  handleIdentifier(int, typeReference)
-                  handleNoTypeArguments(?)
-                  handleType(int, ?)
-                endAsOperatorType(as)
-                handleAsOperator(as)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(b, expression)
+                  handleNoTypeArguments(as)
+                  handleNoArguments(as)
+                  handleSend(b, as)
+                  beginAsOperatorType(as)
+                    handleIdentifier(int, typeReference)
+                    handleNoTypeArguments(?)
+                    handleType(int, ?)
+                  endAsOperatorType(as)
+                  handleAsOperator(as)
+                endParenthesizedExpression(()
                 handleAssignmentExpression(=)
               endInitializer(;)
             endInitializers(2, :, ;)
@@ -117,17 +119,18 @@ beginCompilationUnit(class)
                 handleNoTypeArguments(=)
                 handleNoArguments(=)
                 handleSend(x, =)
-                handleIdentifier(a, expression)
-                handleNoTypeArguments(is)
-                handleNoArguments(is)
-                handleSend(a, is)
-                beginIsOperatorType(is)
-                  handleIdentifier(int, typeReference)
-                  handleNoTypeArguments())
-                  handleType(int, null)
-                endIsOperatorType(is)
-                handleIsOperator(is, null)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(a, expression)
+                  handleNoTypeArguments(is)
+                  handleNoArguments(is)
+                  handleSend(a, is)
+                  beginIsOperatorType(is)
+                    handleIdentifier(int, typeReference)
+                    handleNoTypeArguments())
+                    handleType(int, null)
+                  endIsOperatorType(is)
+                  handleIsOperator(is, null)
+                endParenthesizedExpression(()
                 handleAssignmentExpression(=)
               endInitializer(,)
               beginInitializer(y)
@@ -135,17 +138,18 @@ beginCompilationUnit(class)
                 handleNoTypeArguments(=)
                 handleNoArguments(=)
                 handleSend(y, =)
-                handleIdentifier(b, expression)
-                handleNoTypeArguments(is)
-                handleNoArguments(is)
-                handleSend(b, is)
-                beginIsOperatorType(is)
-                  handleIdentifier(int, typeReference)
-                  handleNoTypeArguments(?)
-                  handleType(int, ?)
-                endIsOperatorType(is)
-                handleIsOperator(is, null)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(b, expression)
+                  handleNoTypeArguments(is)
+                  handleNoArguments(is)
+                  handleSend(b, is)
+                  beginIsOperatorType(is)
+                    handleIdentifier(int, typeReference)
+                    handleNoTypeArguments(?)
+                    handleType(int, ?)
+                  endIsOperatorType(is)
+                  handleIsOperator(is, null)
+                endParenthesizedExpression(()
                 handleAssignmentExpression(=)
               endInitializer(;)
             endInitializers(2, :, ;)
@@ -188,17 +192,18 @@ beginCompilationUnit(class)
                 handleNoTypeArguments(=)
                 handleNoArguments(=)
                 handleSend(x, =)
-                handleIdentifier(a, expression)
-                handleNoTypeArguments(as)
-                handleNoArguments(as)
-                handleSend(a, as)
-                beginAsOperatorType(as)
-                  handleIdentifier(int, typeReference)
-                  handleNoTypeArguments(?)
-                  handleType(int, ?)
-                endAsOperatorType(as)
-                handleAsOperator(as)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(a, expression)
+                  handleNoTypeArguments(as)
+                  handleNoArguments(as)
+                  handleSend(a, as)
+                  beginAsOperatorType(as)
+                    handleIdentifier(int, typeReference)
+                    handleNoTypeArguments(?)
+                    handleType(int, ?)
+                  endAsOperatorType(as)
+                  handleAsOperator(as)
+                endParenthesizedExpression(()
                 handleAssignmentExpression(=)
               endInitializer(,)
               beginInitializer(y)
@@ -206,17 +211,18 @@ beginCompilationUnit(class)
                 handleNoTypeArguments(=)
                 handleNoArguments(=)
                 handleSend(y, =)
-                handleIdentifier(b, expression)
-                handleNoTypeArguments(as)
-                handleNoArguments(as)
-                handleSend(b, as)
-                beginAsOperatorType(as)
-                  handleIdentifier(int, typeReference)
-                  handleNoTypeArguments())
-                  handleType(int, null)
-                endAsOperatorType(as)
-                handleAsOperator(as)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(b, expression)
+                  handleNoTypeArguments(as)
+                  handleNoArguments(as)
+                  handleSend(b, as)
+                  beginAsOperatorType(as)
+                    handleIdentifier(int, typeReference)
+                    handleNoTypeArguments())
+                    handleType(int, null)
+                  endAsOperatorType(as)
+                  handleAsOperator(as)
+                endParenthesizedExpression(()
                 handleAssignmentExpression(=)
               endInitializer(;)
             endInitializers(2, :, ;)
@@ -259,17 +265,18 @@ beginCompilationUnit(class)
                 handleNoTypeArguments(=)
                 handleNoArguments(=)
                 handleSend(x, =)
-                handleIdentifier(a, expression)
-                handleNoTypeArguments(is)
-                handleNoArguments(is)
-                handleSend(a, is)
-                beginIsOperatorType(is)
-                  handleIdentifier(int, typeReference)
-                  handleNoTypeArguments(?)
-                  handleType(int, ?)
-                endIsOperatorType(is)
-                handleIsOperator(is, null)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(a, expression)
+                  handleNoTypeArguments(is)
+                  handleNoArguments(is)
+                  handleSend(a, is)
+                  beginIsOperatorType(is)
+                    handleIdentifier(int, typeReference)
+                    handleNoTypeArguments(?)
+                    handleType(int, ?)
+                  endIsOperatorType(is)
+                  handleIsOperator(is, null)
+                endParenthesizedExpression(()
                 handleAssignmentExpression(=)
               endInitializer(,)
               beginInitializer(y)
@@ -277,17 +284,18 @@ beginCompilationUnit(class)
                 handleNoTypeArguments(=)
                 handleNoArguments(=)
                 handleSend(y, =)
-                handleIdentifier(b, expression)
-                handleNoTypeArguments(is)
-                handleNoArguments(is)
-                handleSend(b, is)
-                beginIsOperatorType(is)
-                  handleIdentifier(int, typeReference)
-                  handleNoTypeArguments())
-                  handleType(int, null)
-                endIsOperatorType(is)
-                handleIsOperator(is, null)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(b, expression)
+                  handleNoTypeArguments(is)
+                  handleNoArguments(is)
+                  handleSend(b, is)
+                  beginIsOperatorType(is)
+                    handleIdentifier(int, typeReference)
+                    handleNoTypeArguments())
+                    handleType(int, null)
+                  endIsOperatorType(is)
+                  handleIsOperator(is, null)
+                endParenthesizedExpression(()
                 handleAssignmentExpression(=)
               endInitializer(;)
             endInitializers(2, :, ;)
@@ -330,17 +338,18 @@ beginCompilationUnit(class)
                 handleNoTypeArguments(=)
                 handleNoArguments(=)
                 handleSend(x, =)
-                handleIdentifier(a, expression)
-                handleNoTypeArguments(as)
-                handleNoArguments(as)
-                handleSend(a, as)
-                beginAsOperatorType(as)
-                  handleIdentifier(int, typeReference)
-                  handleNoTypeArguments())
-                  handleType(int, null)
-                endAsOperatorType(as)
-                handleAsOperator(as)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(a, expression)
+                  handleNoTypeArguments(as)
+                  handleNoArguments(as)
+                  handleSend(a, as)
+                  beginAsOperatorType(as)
+                    handleIdentifier(int, typeReference)
+                    handleNoTypeArguments())
+                    handleType(int, null)
+                  endAsOperatorType(as)
+                  handleAsOperator(as)
+                endParenthesizedExpression(()
                 handleAssignmentExpression(=)
               endInitializer(,)
               beginInitializer(y)
@@ -348,17 +357,18 @@ beginCompilationUnit(class)
                 handleNoTypeArguments(=)
                 handleNoArguments(=)
                 handleSend(y, =)
-                handleIdentifier(b, expression)
-                handleNoTypeArguments(as)
-                handleNoArguments(as)
-                handleSend(b, as)
-                beginAsOperatorType(as)
-                  handleIdentifier(int, typeReference)
-                  handleNoTypeArguments(?)
-                  handleType(int, ?)
-                endAsOperatorType(as)
-                handleAsOperator(as)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(b, expression)
+                  handleNoTypeArguments(as)
+                  handleNoArguments(as)
+                  handleSend(b, as)
+                  beginAsOperatorType(as)
+                    handleIdentifier(int, typeReference)
+                    handleNoTypeArguments(?)
+                    handleType(int, ?)
+                  endAsOperatorType(as)
+                  handleAsOperator(as)
+                endParenthesizedExpression(()
                 handleAssignmentExpression(=)
               endInitializer({)
             endInitializers(2, :, {)
@@ -402,17 +412,18 @@ beginCompilationUnit(class)
                 handleNoTypeArguments(=)
                 handleNoArguments(=)
                 handleSend(x, =)
-                handleIdentifier(a, expression)
-                handleNoTypeArguments(is)
-                handleNoArguments(is)
-                handleSend(a, is)
-                beginIsOperatorType(is)
-                  handleIdentifier(int, typeReference)
-                  handleNoTypeArguments())
-                  handleType(int, null)
-                endIsOperatorType(is)
-                handleIsOperator(is, null)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(a, expression)
+                  handleNoTypeArguments(is)
+                  handleNoArguments(is)
+                  handleSend(a, is)
+                  beginIsOperatorType(is)
+                    handleIdentifier(int, typeReference)
+                    handleNoTypeArguments())
+                    handleType(int, null)
+                  endIsOperatorType(is)
+                  handleIsOperator(is, null)
+                endParenthesizedExpression(()
                 handleAssignmentExpression(=)
               endInitializer(,)
               beginInitializer(y)
@@ -420,17 +431,18 @@ beginCompilationUnit(class)
                 handleNoTypeArguments(=)
                 handleNoArguments(=)
                 handleSend(y, =)
-                handleIdentifier(b, expression)
-                handleNoTypeArguments(is)
-                handleNoArguments(is)
-                handleSend(b, is)
-                beginIsOperatorType(is)
-                  handleIdentifier(int, typeReference)
-                  handleNoTypeArguments(?)
-                  handleType(int, ?)
-                endIsOperatorType(is)
-                handleIsOperator(is, null)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(b, expression)
+                  handleNoTypeArguments(is)
+                  handleNoArguments(is)
+                  handleSend(b, is)
+                  beginIsOperatorType(is)
+                    handleIdentifier(int, typeReference)
+                    handleNoTypeArguments(?)
+                    handleType(int, ?)
+                  endIsOperatorType(is)
+                  handleIsOperator(is, null)
+                endParenthesizedExpression(()
                 handleAssignmentExpression(=)
               endInitializer({)
             endInitializers(2, :, {)
@@ -474,17 +486,18 @@ beginCompilationUnit(class)
                 handleNoTypeArguments(=)
                 handleNoArguments(=)
                 handleSend(x, =)
-                handleIdentifier(a, expression)
-                handleNoTypeArguments(as)
-                handleNoArguments(as)
-                handleSend(a, as)
-                beginAsOperatorType(as)
-                  handleIdentifier(int, typeReference)
-                  handleNoTypeArguments(?)
-                  handleType(int, ?)
-                endAsOperatorType(as)
-                handleAsOperator(as)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(a, expression)
+                  handleNoTypeArguments(as)
+                  handleNoArguments(as)
+                  handleSend(a, as)
+                  beginAsOperatorType(as)
+                    handleIdentifier(int, typeReference)
+                    handleNoTypeArguments(?)
+                    handleType(int, ?)
+                  endAsOperatorType(as)
+                  handleAsOperator(as)
+                endParenthesizedExpression(()
                 handleAssignmentExpression(=)
               endInitializer(,)
               beginInitializer(y)
@@ -492,17 +505,18 @@ beginCompilationUnit(class)
                 handleNoTypeArguments(=)
                 handleNoArguments(=)
                 handleSend(y, =)
-                handleIdentifier(b, expression)
-                handleNoTypeArguments(as)
-                handleNoArguments(as)
-                handleSend(b, as)
-                beginAsOperatorType(as)
-                  handleIdentifier(int, typeReference)
-                  handleNoTypeArguments())
-                  handleType(int, null)
-                endAsOperatorType(as)
-                handleAsOperator(as)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(b, expression)
+                  handleNoTypeArguments(as)
+                  handleNoArguments(as)
+                  handleSend(b, as)
+                  beginAsOperatorType(as)
+                    handleIdentifier(int, typeReference)
+                    handleNoTypeArguments())
+                    handleType(int, null)
+                  endAsOperatorType(as)
+                  handleAsOperator(as)
+                endParenthesizedExpression(()
                 handleAssignmentExpression(=)
               endInitializer({)
             endInitializers(2, :, {)
@@ -546,17 +560,18 @@ beginCompilationUnit(class)
                 handleNoTypeArguments(=)
                 handleNoArguments(=)
                 handleSend(x, =)
-                handleIdentifier(a, expression)
-                handleNoTypeArguments(is)
-                handleNoArguments(is)
-                handleSend(a, is)
-                beginIsOperatorType(is)
-                  handleIdentifier(int, typeReference)
-                  handleNoTypeArguments(?)
-                  handleType(int, ?)
-                endIsOperatorType(is)
-                handleIsOperator(is, null)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(a, expression)
+                  handleNoTypeArguments(is)
+                  handleNoArguments(is)
+                  handleSend(a, is)
+                  beginIsOperatorType(is)
+                    handleIdentifier(int, typeReference)
+                    handleNoTypeArguments(?)
+                    handleType(int, ?)
+                  endIsOperatorType(is)
+                  handleIsOperator(is, null)
+                endParenthesizedExpression(()
                 handleAssignmentExpression(=)
               endInitializer(,)
               beginInitializer(y)
@@ -564,17 +579,18 @@ beginCompilationUnit(class)
                 handleNoTypeArguments(=)
                 handleNoArguments(=)
                 handleSend(y, =)
-                handleIdentifier(b, expression)
-                handleNoTypeArguments(is)
-                handleNoArguments(is)
-                handleSend(b, is)
-                beginIsOperatorType(is)
-                  handleIdentifier(int, typeReference)
-                  handleNoTypeArguments())
-                  handleType(int, null)
-                endIsOperatorType(is)
-                handleIsOperator(is, null)
-                handleParenthesizedExpression(()
+                beginParenthesizedExpressionOrRecordLiteral(()
+                  handleIdentifier(b, expression)
+                  handleNoTypeArguments(is)
+                  handleNoArguments(is)
+                  handleSend(b, is)
+                  beginIsOperatorType(is)
+                    handleIdentifier(int, typeReference)
+                    handleNoTypeArguments())
+                    handleType(int, null)
+                  endIsOperatorType(is)
+                  handleIsOperator(is, null)
+                endParenthesizedExpression(()
                 handleAssignmentExpression(=)
               endInitializer({)
             endInitializers(2, :, {)

pkg/front_end/parser_testcases/nnbd/issue_49132_prime.dart.intertwined.expect

@@ -95,34 +95,33 @@ parseUnit(class)
                             parsePrecedenceExpression(=, 1, true)
                               parseUnaryExpression(=, true)
                                 parsePrimary(=, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(=)
-                                    parseParenthesizedExpression(=)
-                                      parseExpressionInParenthesis(=)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(a, expression)
-                                                      listener: handleNoTypeArguments(as)
-                                                      parseArgumentsOpt(a)
-                                                        listener: handleNoArguments(as)
-                                                      listener: handleSend(a, as)
-                                              parseAsOperatorRest(a)
-                                                listener: beginAsOperatorType(as)
-                                                computeTypeAfterIsOrAs(as)
-                                                listener: handleIdentifier(int, typeReference)
-                                                listener: handleNoTypeArguments())
-                                                listener: handleType(int, null)
-                                                listener: endAsOperatorType(as)
-                                                listener: handleAsOperator(as)
-                                                skipChainedAsIsOperators(int)
-                                          ensureCloseParen(int, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                    parseParenthesizedExpressionOrRecordLiteral(=)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(a, expression)
+                                                  listener: handleNoTypeArguments(as)
+                                                  parseArgumentsOpt(a)
+                                                    listener: handleNoArguments(as)
+                                                  listener: handleSend(a, as)
+                                          parseAsOperatorRest(a)
+                                            listener: beginAsOperatorType(as)
+                                            computeTypeAfterIsOrAs(as)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments())
+                                            listener: handleType(int, null)
+                                            listener: endAsOperatorType(as)
+                                            listener: handleAsOperator(as)
+                                            skipChainedAsIsOperators(int)
+                                      ensureCloseParen(int, ()
+                                      listener: endParenthesizedExpression(()
                             listener: handleAssignmentExpression(=)
                         listener: endInitializer(,)
                     parseInitializer(,)
@@ -144,34 +143,33 @@ parseUnit(class)
                             parsePrecedenceExpression(=, 1, true)
                               parseUnaryExpression(=, true)
                                 parsePrimary(=, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(=)
-                                    parseParenthesizedExpression(=)
-                                      parseExpressionInParenthesis(=)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(b, expression)
-                                                      listener: handleNoTypeArguments(as)
-                                                      parseArgumentsOpt(b)
-                                                        listener: handleNoArguments(as)
-                                                      listener: handleSend(b, as)
-                                              parseAsOperatorRest(b)
-                                                listener: beginAsOperatorType(as)
-                                                computeTypeAfterIsOrAs(as)
-                                                listener: handleIdentifier(int, typeReference)
-                                                listener: handleNoTypeArguments(?)
-                                                listener: handleType(int, ?)
-                                                listener: endAsOperatorType(as)
-                                                listener: handleAsOperator(as)
-                                                skipChainedAsIsOperators(?)
-                                          ensureCloseParen(?, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                    parseParenthesizedExpressionOrRecordLiteral(=)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(b, expression)
+                                                  listener: handleNoTypeArguments(as)
+                                                  parseArgumentsOpt(b)
+                                                    listener: handleNoArguments(as)
+                                                  listener: handleSend(b, as)
+                                          parseAsOperatorRest(b)
+                                            listener: beginAsOperatorType(as)
+                                            computeTypeAfterIsOrAs(as)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments(?)
+                                            listener: handleType(int, ?)
+                                            listener: endAsOperatorType(as)
+                                            listener: handleAsOperator(as)
+                                            skipChainedAsIsOperators(?)
+                                      ensureCloseParen(?, ()
+                                      listener: endParenthesizedExpression(()
                             listener: handleAssignmentExpression(=)
                         listener: endInitializer(;)
                     listener: endInitializers(2, :, ;)
@@ -253,34 +251,33 @@ parseUnit(class)
                             parsePrecedenceExpression(=, 1, true)
                               parseUnaryExpression(=, true)
                                 parsePrimary(=, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(=)
-                                    parseParenthesizedExpression(=)
-                                      parseExpressionInParenthesis(=)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(a, expression)
-                                                      listener: handleNoTypeArguments(is)
-                                                      parseArgumentsOpt(a)
-                                                        listener: handleNoArguments(is)
-                                                      listener: handleSend(a, is)
-                                              parseIsOperatorRest(a)
-                                                listener: beginIsOperatorType(is)
-                                                computeTypeAfterIsOrAs(is)
-                                                listener: handleIdentifier(int, typeReference)
-                                                listener: handleNoTypeArguments())
-                                                listener: handleType(int, null)
-                                                listener: endIsOperatorType(is)
-                                                listener: handleIsOperator(is, null)
-                                                skipChainedAsIsOperators(int)
-                                          ensureCloseParen(int, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                    parseParenthesizedExpressionOrRecordLiteral(=)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(a, expression)
+                                                  listener: handleNoTypeArguments(is)
+                                                  parseArgumentsOpt(a)
+                                                    listener: handleNoArguments(is)
+                                                  listener: handleSend(a, is)
+                                          parseIsOperatorRest(a)
+                                            listener: beginIsOperatorType(is)
+                                            computeTypeAfterIsOrAs(is)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments())
+                                            listener: handleType(int, null)
+                                            listener: endIsOperatorType(is)
+                                            listener: handleIsOperator(is, null)
+                                            skipChainedAsIsOperators(int)
+                                      ensureCloseParen(int, ()
+                                      listener: endParenthesizedExpression(()
                             listener: handleAssignmentExpression(=)
                         listener: endInitializer(,)
                     parseInitializer(,)
@@ -302,34 +299,33 @@ parseUnit(class)
                             parsePrecedenceExpression(=, 1, true)
                               parseUnaryExpression(=, true)
                                 parsePrimary(=, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(=)
-                                    parseParenthesizedExpression(=)
-                                      parseExpressionInParenthesis(=)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(b, expression)
-                                                      listener: handleNoTypeArguments(is)
-                                                      parseArgumentsOpt(b)
-                                                        listener: handleNoArguments(is)
-                                                      listener: handleSend(b, is)
-                                              parseIsOperatorRest(b)
-                                                listener: beginIsOperatorType(is)
-                                                computeTypeAfterIsOrAs(is)
-                                                listener: handleIdentifier(int, typeReference)
-                                                listener: handleNoTypeArguments(?)
-                                                listener: handleType(int, ?)
-                                                listener: endIsOperatorType(is)
-                                                listener: handleIsOperator(is, null)
-                                                skipChainedAsIsOperators(?)
-                                          ensureCloseParen(?, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                    parseParenthesizedExpressionOrRecordLiteral(=)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(b, expression)
+                                                  listener: handleNoTypeArguments(is)
+                                                  parseArgumentsOpt(b)
+                                                    listener: handleNoArguments(is)
+                                                  listener: handleSend(b, is)
+                                          parseIsOperatorRest(b)
+                                            listener: beginIsOperatorType(is)
+                                            computeTypeAfterIsOrAs(is)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments(?)
+                                            listener: handleType(int, ?)
+                                            listener: endIsOperatorType(is)
+                                            listener: handleIsOperator(is, null)
+                                            skipChainedAsIsOperators(?)
+                                      ensureCloseParen(?, ()
+                                      listener: endParenthesizedExpression(()
                             listener: handleAssignmentExpression(=)
                         listener: endInitializer(;)
                     listener: endInitializers(2, :, ;)
@@ -411,34 +407,33 @@ parseUnit(class)
                             parsePrecedenceExpression(=, 1, true)
                               parseUnaryExpression(=, true)
                                 parsePrimary(=, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(=)
-                                    parseParenthesizedExpression(=)
-                                      parseExpressionInParenthesis(=)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(a, expression)
-                                                      listener: handleNoTypeArguments(as)
-                                                      parseArgumentsOpt(a)
-                                                        listener: handleNoArguments(as)
-                                                      listener: handleSend(a, as)
-                                              parseAsOperatorRest(a)
-                                                listener: beginAsOperatorType(as)
-                                                computeTypeAfterIsOrAs(as)
-                                                listener: handleIdentifier(int, typeReference)
-                                                listener: handleNoTypeArguments(?)
-                                                listener: handleType(int, ?)
-                                                listener: endAsOperatorType(as)
-                                                listener: handleAsOperator(as)
-                                                skipChainedAsIsOperators(?)
-                                          ensureCloseParen(?, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                    parseParenthesizedExpressionOrRecordLiteral(=)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(a, expression)
+                                                  listener: handleNoTypeArguments(as)
+                                                  parseArgumentsOpt(a)
+                                                    listener: handleNoArguments(as)
+                                                  listener: handleSend(a, as)
+                                          parseAsOperatorRest(a)
+                                            listener: beginAsOperatorType(as)
+                                            computeTypeAfterIsOrAs(as)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments(?)
+                                            listener: handleType(int, ?)
+                                            listener: endAsOperatorType(as)
+                                            listener: handleAsOperator(as)
+                                            skipChainedAsIsOperators(?)
+                                      ensureCloseParen(?, ()
+                                      listener: endParenthesizedExpression(()
                             listener: handleAssignmentExpression(=)
                         listener: endInitializer(,)
                     parseInitializer(,)
@@ -460,34 +455,33 @@ parseUnit(class)
                             parsePrecedenceExpression(=, 1, true)
                               parseUnaryExpression(=, true)
                                 parsePrimary(=, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(=)
-                                    parseParenthesizedExpression(=)
-                                      parseExpressionInParenthesis(=)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(b, expression)
-                                                      listener: handleNoTypeArguments(as)
-                                                      parseArgumentsOpt(b)
-                                                        listener: handleNoArguments(as)
-                                                      listener: handleSend(b, as)
-                                              parseAsOperatorRest(b)
-                                                listener: beginAsOperatorType(as)
-                                                computeTypeAfterIsOrAs(as)
-                                                listener: handleIdentifier(int, typeReference)
-                                                listener: handleNoTypeArguments())
-                                                listener: handleType(int, null)
-                                                listener: endAsOperatorType(as)
-                                                listener: handleAsOperator(as)
-                                                skipChainedAsIsOperators(int)
-                                          ensureCloseParen(int, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                    parseParenthesizedExpressionOrRecordLiteral(=)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(b, expression)
+                                                  listener: handleNoTypeArguments(as)
+                                                  parseArgumentsOpt(b)
+                                                    listener: handleNoArguments(as)
+                                                  listener: handleSend(b, as)
+                                          parseAsOperatorRest(b)
+                                            listener: beginAsOperatorType(as)
+                                            computeTypeAfterIsOrAs(as)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments())
+                                            listener: handleType(int, null)
+                                            listener: endAsOperatorType(as)
+                                            listener: handleAsOperator(as)
+                                            skipChainedAsIsOperators(int)
+                                      ensureCloseParen(int, ()
+                                      listener: endParenthesizedExpression(()
                             listener: handleAssignmentExpression(=)
                         listener: endInitializer(;)
                     listener: endInitializers(2, :, ;)
@@ -569,34 +563,33 @@ parseUnit(class)
                             parsePrecedenceExpression(=, 1, true)
                               parseUnaryExpression(=, true)
                                 parsePrimary(=, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(=)
-                                    parseParenthesizedExpression(=)
-                                      parseExpressionInParenthesis(=)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(a, expression)
-                                                      listener: handleNoTypeArguments(is)
-                                                      parseArgumentsOpt(a)
-                                                        listener: handleNoArguments(is)
-                                                      listener: handleSend(a, is)
-                                              parseIsOperatorRest(a)
-                                                listener: beginIsOperatorType(is)
-                                                computeTypeAfterIsOrAs(is)
-                                                listener: handleIdentifier(int, typeReference)
-                                                listener: handleNoTypeArguments(?)
-                                                listener: handleType(int, ?)
-                                                listener: endIsOperatorType(is)
-                                                listener: handleIsOperator(is, null)
-                                                skipChainedAsIsOperators(?)
-                                          ensureCloseParen(?, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                    parseParenthesizedExpressionOrRecordLiteral(=)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(a, expression)
+                                                  listener: handleNoTypeArguments(is)
+                                                  parseArgumentsOpt(a)
+                                                    listener: handleNoArguments(is)
+                                                  listener: handleSend(a, is)
+                                          parseIsOperatorRest(a)
+                                            listener: beginIsOperatorType(is)
+                                            computeTypeAfterIsOrAs(is)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments(?)
+                                            listener: handleType(int, ?)
+                                            listener: endIsOperatorType(is)
+                                            listener: handleIsOperator(is, null)
+                                            skipChainedAsIsOperators(?)
+                                      ensureCloseParen(?, ()
+                                      listener: endParenthesizedExpression(()
                             listener: handleAssignmentExpression(=)
                         listener: endInitializer(,)
                     parseInitializer(,)
@@ -618,34 +611,33 @@ parseUnit(class)
                             parsePrecedenceExpression(=, 1, true)
                               parseUnaryExpression(=, true)
                                 parsePrimary(=, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(=)
-                                    parseParenthesizedExpression(=)
-                                      parseExpressionInParenthesis(=)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(b, expression)
-                                                      listener: handleNoTypeArguments(is)
-                                                      parseArgumentsOpt(b)
-                                                        listener: handleNoArguments(is)
-                                                      listener: handleSend(b, is)
-                                              parseIsOperatorRest(b)
-                                                listener: beginIsOperatorType(is)
-                                                computeTypeAfterIsOrAs(is)
-                                                listener: handleIdentifier(int, typeReference)
-                                                listener: handleNoTypeArguments())
-                                                listener: handleType(int, null)
-                                                listener: endIsOperatorType(is)
-                                                listener: handleIsOperator(is, null)
-                                                skipChainedAsIsOperators(int)
-                                          ensureCloseParen(int, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                    parseParenthesizedExpressionOrRecordLiteral(=)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(b, expression)
+                                                  listener: handleNoTypeArguments(is)
+                                                  parseArgumentsOpt(b)
+                                                    listener: handleNoArguments(is)
+                                                  listener: handleSend(b, is)
+                                          parseIsOperatorRest(b)
+                                            listener: beginIsOperatorType(is)
+                                            computeTypeAfterIsOrAs(is)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments())
+                                            listener: handleType(int, null)
+                                            listener: endIsOperatorType(is)
+                                            listener: handleIsOperator(is, null)
+                                            skipChainedAsIsOperators(int)
+                                      ensureCloseParen(int, ()
+                                      listener: endParenthesizedExpression(()
                             listener: handleAssignmentExpression(=)
                         listener: endInitializer(;)
                     listener: endInitializers(2, :, ;)
@@ -727,34 +719,33 @@ parseUnit(class)
                             parsePrecedenceExpression(=, 1, true)
                               parseUnaryExpression(=, true)
                                 parsePrimary(=, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(=)
-                                    parseParenthesizedExpression(=)
-                                      parseExpressionInParenthesis(=)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(a, expression)
-                                                      listener: handleNoTypeArguments(as)
-                                                      parseArgumentsOpt(a)
-                                                        listener: handleNoArguments(as)
-                                                      listener: handleSend(a, as)
-                                              parseAsOperatorRest(a)
-                                                listener: beginAsOperatorType(as)
-                                                computeTypeAfterIsOrAs(as)
-                                                listener: handleIdentifier(int, typeReference)
-                                                listener: handleNoTypeArguments())
-                                                listener: handleType(int, null)
-                                                listener: endAsOperatorType(as)
-                                                listener: handleAsOperator(as)
-                                                skipChainedAsIsOperators(int)
-                                          ensureCloseParen(int, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                    parseParenthesizedExpressionOrRecordLiteral(=)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(a, expression)
+                                                  listener: handleNoTypeArguments(as)
+                                                  parseArgumentsOpt(a)
+                                                    listener: handleNoArguments(as)
+                                                  listener: handleSend(a, as)
+                                          parseAsOperatorRest(a)
+                                            listener: beginAsOperatorType(as)
+                                            computeTypeAfterIsOrAs(as)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments())
+                                            listener: handleType(int, null)
+                                            listener: endAsOperatorType(as)
+                                            listener: handleAsOperator(as)
+                                            skipChainedAsIsOperators(int)
+                                      ensureCloseParen(int, ()
+                                      listener: endParenthesizedExpression(()
                             listener: handleAssignmentExpression(=)
                         listener: endInitializer(,)
                     parseInitializer(,)
@@ -776,34 +767,33 @@ parseUnit(class)
                             parsePrecedenceExpression(=, 1, true)
                               parseUnaryExpression(=, true)
                                 parsePrimary(=, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(=)
-                                    parseParenthesizedExpression(=)
-                                      parseExpressionInParenthesis(=)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(b, expression)
-                                                      listener: handleNoTypeArguments(as)
-                                                      parseArgumentsOpt(b)
-                                                        listener: handleNoArguments(as)
-                                                      listener: handleSend(b, as)
-                                              parseAsOperatorRest(b)
-                                                listener: beginAsOperatorType(as)
-                                                computeTypeAfterIsOrAs(as)
-                                                listener: handleIdentifier(int, typeReference)
-                                                listener: handleNoTypeArguments(?)
-                                                listener: handleType(int, ?)
-                                                listener: endAsOperatorType(as)
-                                                listener: handleAsOperator(as)
-                                                skipChainedAsIsOperators(?)
-                                          ensureCloseParen(?, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                    parseParenthesizedExpressionOrRecordLiteral(=)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(b, expression)
+                                                  listener: handleNoTypeArguments(as)
+                                                  parseArgumentsOpt(b)
+                                                    listener: handleNoArguments(as)
+                                                  listener: handleSend(b, as)
+                                          parseAsOperatorRest(b)
+                                            listener: beginAsOperatorType(as)
+                                            computeTypeAfterIsOrAs(as)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments(?)
+                                            listener: handleType(int, ?)
+                                            listener: endAsOperatorType(as)
+                                            listener: handleAsOperator(as)
+                                            skipChainedAsIsOperators(?)
+                                      ensureCloseParen(?, ()
+                                      listener: endParenthesizedExpression(()
                             listener: handleAssignmentExpression(=)
                         listener: endInitializer({)
                     listener: endInitializers(2, :, {)
@@ -887,34 +877,33 @@ parseUnit(class)
                             parsePrecedenceExpression(=, 1, true)
                               parseUnaryExpression(=, true)
                                 parsePrimary(=, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(=)
-                                    parseParenthesizedExpression(=)
-                                      parseExpressionInParenthesis(=)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(a, expression)
-                                                      listener: handleNoTypeArguments(is)
-                                                      parseArgumentsOpt(a)
-                                                        listener: handleNoArguments(is)
-                                                      listener: handleSend(a, is)
-                                              parseIsOperatorRest(a)
-                                                listener: beginIsOperatorType(is)
-                                                computeTypeAfterIsOrAs(is)
-                                                listener: handleIdentifier(int, typeReference)
-                                                listener: handleNoTypeArguments())
-                                                listener: handleType(int, null)
-                                                listener: endIsOperatorType(is)
-                                                listener: handleIsOperator(is, null)
-                                                skipChainedAsIsOperators(int)
-                                          ensureCloseParen(int, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                    parseParenthesizedExpressionOrRecordLiteral(=)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(a, expression)
+                                                  listener: handleNoTypeArguments(is)
+                                                  parseArgumentsOpt(a)
+                                                    listener: handleNoArguments(is)
+                                                  listener: handleSend(a, is)
+                                          parseIsOperatorRest(a)
+                                            listener: beginIsOperatorType(is)
+                                            computeTypeAfterIsOrAs(is)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments())
+                                            listener: handleType(int, null)
+                                            listener: endIsOperatorType(is)
+                                            listener: handleIsOperator(is, null)
+                                            skipChainedAsIsOperators(int)
+                                      ensureCloseParen(int, ()
+                                      listener: endParenthesizedExpression(()
                             listener: handleAssignmentExpression(=)
                         listener: endInitializer(,)
                     parseInitializer(,)
@@ -936,34 +925,33 @@ parseUnit(class)
                             parsePrecedenceExpression(=, 1, true)
                               parseUnaryExpression(=, true)
                                 parsePrimary(=, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(=)
-                                    parseParenthesizedExpression(=)
-                                      parseExpressionInParenthesis(=)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(b, expression)
-                                                      listener: handleNoTypeArguments(is)
-                                                      parseArgumentsOpt(b)
-                                                        listener: handleNoArguments(is)
-                                                      listener: handleSend(b, is)
-                                              parseIsOperatorRest(b)
-                                                listener: beginIsOperatorType(is)
-                                                computeTypeAfterIsOrAs(is)
-                                                listener: handleIdentifier(int, typeReference)
-                                                listener: handleNoTypeArguments(?)
-                                                listener: handleType(int, ?)
-                                                listener: endIsOperatorType(is)
-                                                listener: handleIsOperator(is, null)
-                                                skipChainedAsIsOperators(?)
-                                          ensureCloseParen(?, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                    parseParenthesizedExpressionOrRecordLiteral(=)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(b, expression)
+                                                  listener: handleNoTypeArguments(is)
+                                                  parseArgumentsOpt(b)
+                                                    listener: handleNoArguments(is)
+                                                  listener: handleSend(b, is)
+                                          parseIsOperatorRest(b)
+                                            listener: beginIsOperatorType(is)
+                                            computeTypeAfterIsOrAs(is)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments(?)
+                                            listener: handleType(int, ?)
+                                            listener: endIsOperatorType(is)
+                                            listener: handleIsOperator(is, null)
+                                            skipChainedAsIsOperators(?)
+                                      ensureCloseParen(?, ()
+                                      listener: endParenthesizedExpression(()
                             listener: handleAssignmentExpression(=)
                         listener: endInitializer({)
                     listener: endInitializers(2, :, {)
@@ -1047,34 +1035,33 @@ parseUnit(class)
                             parsePrecedenceExpression(=, 1, true)
                               parseUnaryExpression(=, true)
                                 parsePrimary(=, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(=)
-                                    parseParenthesizedExpression(=)
-                                      parseExpressionInParenthesis(=)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(a, expression)
-                                                      listener: handleNoTypeArguments(as)
-                                                      parseArgumentsOpt(a)
-                                                        listener: handleNoArguments(as)
-                                                      listener: handleSend(a, as)
-                                              parseAsOperatorRest(a)
-                                                listener: beginAsOperatorType(as)
-                                                computeTypeAfterIsOrAs(as)
-                                                listener: handleIdentifier(int, typeReference)
-                                                listener: handleNoTypeArguments(?)
-                                                listener: handleType(int, ?)
-                                                listener: endAsOperatorType(as)
-                                                listener: handleAsOperator(as)
-                                                skipChainedAsIsOperators(?)
-                                          ensureCloseParen(?, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                    parseParenthesizedExpressionOrRecordLiteral(=)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(a, expression)
+                                                  listener: handleNoTypeArguments(as)
+                                                  parseArgumentsOpt(a)
+                                                    listener: handleNoArguments(as)
+                                                  listener: handleSend(a, as)
+                                          parseAsOperatorRest(a)
+                                            listener: beginAsOperatorType(as)
+                                            computeTypeAfterIsOrAs(as)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments(?)
+                                            listener: handleType(int, ?)
+                                            listener: endAsOperatorType(as)
+                                            listener: handleAsOperator(as)
+                                            skipChainedAsIsOperators(?)
+                                      ensureCloseParen(?, ()
+                                      listener: endParenthesizedExpression(()
                             listener: handleAssignmentExpression(=)
                         listener: endInitializer(,)
                     parseInitializer(,)
@@ -1096,34 +1083,33 @@ parseUnit(class)
                             parsePrecedenceExpression(=, 1, true)
                               parseUnaryExpression(=, true)
                                 parsePrimary(=, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(=)
-                                    parseParenthesizedExpression(=)
-                                      parseExpressionInParenthesis(=)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(b, expression)
-                                                      listener: handleNoTypeArguments(as)
-                                                      parseArgumentsOpt(b)
-                                                        listener: handleNoArguments(as)
-                                                      listener: handleSend(b, as)
-                                              parseAsOperatorRest(b)
-                                                listener: beginAsOperatorType(as)
-                                                computeTypeAfterIsOrAs(as)
-                                                listener: handleIdentifier(int, typeReference)
-                                                listener: handleNoTypeArguments())
-                                                listener: handleType(int, null)
-                                                listener: endAsOperatorType(as)
-                                                listener: handleAsOperator(as)
-                                                skipChainedAsIsOperators(int)
-                                          ensureCloseParen(int, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                    parseParenthesizedExpressionOrRecordLiteral(=)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(b, expression)
+                                                  listener: handleNoTypeArguments(as)
+                                                  parseArgumentsOpt(b)
+                                                    listener: handleNoArguments(as)
+                                                  listener: handleSend(b, as)
+                                          parseAsOperatorRest(b)
+                                            listener: beginAsOperatorType(as)
+                                            computeTypeAfterIsOrAs(as)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments())
+                                            listener: handleType(int, null)
+                                            listener: endAsOperatorType(as)
+                                            listener: handleAsOperator(as)
+                                            skipChainedAsIsOperators(int)
+                                      ensureCloseParen(int, ()
+                                      listener: endParenthesizedExpression(()
                             listener: handleAssignmentExpression(=)
                         listener: endInitializer({)
                     listener: endInitializers(2, :, {)
@@ -1207,34 +1193,33 @@ parseUnit(class)
                             parsePrecedenceExpression(=, 1, true)
                               parseUnaryExpression(=, true)
                                 parsePrimary(=, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(=)
-                                    parseParenthesizedExpression(=)
-                                      parseExpressionInParenthesis(=)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(a, expression)
-                                                      listener: handleNoTypeArguments(is)
-                                                      parseArgumentsOpt(a)
-                                                        listener: handleNoArguments(is)
-                                                      listener: handleSend(a, is)
-                                              parseIsOperatorRest(a)
-                                                listener: beginIsOperatorType(is)
-                                                computeTypeAfterIsOrAs(is)
-                                                listener: handleIdentifier(int, typeReference)
-                                                listener: handleNoTypeArguments(?)
-                                                listener: handleType(int, ?)
-                                                listener: endIsOperatorType(is)
-                                                listener: handleIsOperator(is, null)
-                                                skipChainedAsIsOperators(?)
-                                          ensureCloseParen(?, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                    parseParenthesizedExpressionOrRecordLiteral(=)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(a, expression)
+                                                  listener: handleNoTypeArguments(is)
+                                                  parseArgumentsOpt(a)
+                                                    listener: handleNoArguments(is)
+                                                  listener: handleSend(a, is)
+                                          parseIsOperatorRest(a)
+                                            listener: beginIsOperatorType(is)
+                                            computeTypeAfterIsOrAs(is)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments(?)
+                                            listener: handleType(int, ?)
+                                            listener: endIsOperatorType(is)
+                                            listener: handleIsOperator(is, null)
+                                            skipChainedAsIsOperators(?)
+                                      ensureCloseParen(?, ()
+                                      listener: endParenthesizedExpression(()
                             listener: handleAssignmentExpression(=)
                         listener: endInitializer(,)
                     parseInitializer(,)
@@ -1256,34 +1241,33 @@ parseUnit(class)
                             parsePrecedenceExpression(=, 1, true)
                               parseUnaryExpression(=, true)
                                 parsePrimary(=, expression)
-                                  parseParenthesizedExpressionOrFunctionLiteral(=)
-                                    parseParenthesizedExpression(=)
-                                      parseExpressionInParenthesis(=)
-                                        parseExpressionInParenthesisRest(()
-                                          parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
-                                                  parseSendOrFunctionLiteral((, expression)
-                                                    parseSend((, expression)
-                                                      isNextIdentifier(()
-                                                      ensureIdentifier((, expression)
-                                                        listener: handleIdentifier(b, expression)
-                                                      listener: handleNoTypeArguments(is)
-                                                      parseArgumentsOpt(b)
-                                                        listener: handleNoArguments(is)
-                                                      listener: handleSend(b, is)
-                                              parseIsOperatorRest(b)
-                                                listener: beginIsOperatorType(is)
-                                                computeTypeAfterIsOrAs(is)
-                                                listener: handleIdentifier(int, typeReference)
-                                                listener: handleNoTypeArguments())
-                                                listener: handleType(int, null)
-                                                listener: endIsOperatorType(is)
-                                                listener: handleIsOperator(is, null)
-                                                skipChainedAsIsOperators(int)
-                                          ensureCloseParen(int, ()
-                                      listener: handleParenthesizedExpression(()
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                    parseParenthesizedExpressionOrRecordLiteral(=)
+                                      listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                      parseExpression(()
+                                        parsePrecedenceExpression((, 1, true)
+                                          parseUnaryExpression((, true)
+                                            parsePrimary((, expression)
+                                              parseSendOrFunctionLiteral((, expression)
+                                                parseSend((, expression)
+                                                  isNextIdentifier(()
+                                                  ensureIdentifier((, expression)
+                                                    listener: handleIdentifier(b, expression)
+                                                  listener: handleNoTypeArguments(is)
+                                                  parseArgumentsOpt(b)
+                                                    listener: handleNoArguments(is)
+                                                  listener: handleSend(b, is)
+                                          parseIsOperatorRest(b)
+                                            listener: beginIsOperatorType(is)
+                                            computeTypeAfterIsOrAs(is)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments())
+                                            listener: handleType(int, null)
+                                            listener: endIsOperatorType(is)
+                                            listener: handleIsOperator(is, null)
+                                            skipChainedAsIsOperators(int)
+                                      ensureCloseParen(int, ()
+                                      listener: endParenthesizedExpression(()
                             listener: handleAssignmentExpression(=)
                         listener: endInitializer({)
                     listener: endInitializers(2, :, {)

pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex_with_parens.dart.expect

@@ -10,16 +10,17 @@ beginCompilationUnit(f)
       endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
       handleAsyncModifier(null, null)
       beginBlockFunctionBody({)
-        handleIdentifier(foo, expression)
-        handleNoTypeArguments(.)
-        handleNoArguments(.)
-        handleSend(foo, .)
-        handleIdentifier(bar, expressionContinuation)
-        handleNoTypeArguments())
-        handleNoArguments())
-        handleSend(bar, ))
-        handleEndingBinaryExpression(.)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(foo, expression)
+          handleNoTypeArguments(.)
+          handleNoArguments(.)
+          handleSend(foo, .)
+          handleIdentifier(bar, expressionContinuation)
+          handleNoTypeArguments())
+          handleNoArguments())
+          handleSend(bar, ))
+          handleEndingBinaryExpression(.)
+        endParenthesizedExpression(()
         handleNonNullAssertExpression(!)
         handleIdentifier(baz, expressionContinuation)
         handleNoTypeArguments([)

pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex_with_parens.dart.intertwined.expect

@@ -37,36 +37,35 @@ parseUnit(f)
                       parsePrecedenceExpression({, 1, true)
                         parseUnaryExpression({, true)
                           parsePrimary({, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral({)
-                              parseParenthesizedExpression({)
-                                parseExpressionInParenthesis({)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(foo, expression)
-                                                listener: handleNoTypeArguments(.)
-                                                parseArgumentsOpt(foo)
-                                                  listener: handleNoArguments(.)
-                                                listener: handleSend(foo, .)
-                                        parsePrimary(., expressionContinuation)
-                                          parseSendOrFunctionLiteral(., expressionContinuation)
-                                            parseSend(., expressionContinuation)
-                                              isNextIdentifier(.)
-                                              ensureIdentifier(., expressionContinuation)
-                                                listener: handleIdentifier(bar, expressionContinuation)
-                                              listener: handleNoTypeArguments())
-                                              parseArgumentsOpt(bar)
-                                                listener: handleNoArguments())
-                                              listener: handleSend(bar, ))
-                                        listener: handleEndingBinaryExpression(.)
-                                    ensureCloseParen(bar, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
+                              parseParenthesizedExpressionOrRecordLiteral({)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(foo, expression)
+                                            listener: handleNoTypeArguments(.)
+                                            parseArgumentsOpt(foo)
+                                              listener: handleNoArguments(.)
+                                            listener: handleSend(foo, .)
+                                    parsePrimary(., expressionContinuation)
+                                      parseSendOrFunctionLiteral(., expressionContinuation)
+                                        parseSend(., expressionContinuation)
+                                          isNextIdentifier(.)
+                                          ensureIdentifier(., expressionContinuation)
+                                            listener: handleIdentifier(bar, expressionContinuation)
+                                          listener: handleNoTypeArguments())
+                                          parseArgumentsOpt(bar)
+                                            listener: handleNoArguments())
+                                          listener: handleSend(bar, ))
+                                    listener: handleEndingBinaryExpression(.)
+                                ensureCloseParen(bar, ()
+                                listener: endParenthesizedExpression(()
                         listener: handleNonNullAssertExpression(!)
                         parsePrimary(., expressionContinuation)
                           parseSendOrFunctionLiteral(., expressionContinuation)

pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2_with_parens.dart.expect

@@ -10,20 +10,23 @@ beginCompilationUnit(f)
       endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
       handleAsyncModifier(null, null)
       beginBlockFunctionBody({)
-        handleIdentifier(obj, expression)
-        handleNoTypeArguments(!)
-        handleNoArguments(!)
-        handleSend(obj, !)
-        handleNonNullAssertExpression(!)
-        handleParenthesizedExpression(()
-        handleIdentifier(arg, expression)
-        handleNoTypeArguments(])
-        handleNoArguments(])
-        handleSend(arg, ])
-        handleIndexedExpression(null, [, ])
-        handleParenthesizedExpression(()
-        handleNonNullAssertExpression(!)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleIdentifier(obj, expression)
+              handleNoTypeArguments(!)
+              handleNoArguments(!)
+              handleSend(obj, !)
+              handleNonNullAssertExpression(!)
+            endParenthesizedExpression(()
+            handleIdentifier(arg, expression)
+            handleNoTypeArguments(])
+            handleNoArguments(])
+            handleSend(arg, ])
+            handleIndexedExpression(null, [, ])
+          endParenthesizedExpression(()
+          handleNonNullAssertExpression(!)
+        endParenthesizedExpression(()
         handleIdentifier(arg2, expression)
         handleNoTypeArguments(])
         handleNoArguments(])

pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2_with_parens.dart.intertwined.expect

@@ -37,62 +37,59 @@ parseUnit(f)
                       parsePrecedenceExpression({, 1, true)
                         parseUnaryExpression({, true)
                           parsePrimary({, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral({)
-                              parseParenthesizedExpression({)
-                                parseExpressionInParenthesis({)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(()
-                                              parseParenthesizedExpression(()
-                                                parseExpressionInParenthesis(()
-                                                  parseExpressionInParenthesisRest(()
-                                                    parseExpression(()
-                                                      parsePrecedenceExpression((, 1, true)
-                                                        parseUnaryExpression((, true)
-                                                          parsePrimary((, expression)
-                                                            parseParenthesizedExpressionOrFunctionLiteral(()
-                                                              parseParenthesizedExpression(()
-                                                                parseExpressionInParenthesis(()
-                                                                  parseExpressionInParenthesisRest(()
-                                                                    parseExpression(()
-                                                                      parsePrecedenceExpression((, 1, true)
-                                                                        parseUnaryExpression((, true)
-                                                                          parsePrimary((, expression)
-                                                                            parseSendOrFunctionLiteral((, expression)
-                                                                              parseSend((, expression)
-                                                                                isNextIdentifier(()
-                                                                                ensureIdentifier((, expression)
-                                                                                  listener: handleIdentifier(obj, expression)
-                                                                                listener: handleNoTypeArguments(!)
-                                                                                parseArgumentsOpt(obj)
-                                                                                  listener: handleNoArguments(!)
-                                                                                listener: handleSend(obj, !)
-                                                                        listener: handleNonNullAssertExpression(!)
-                                                                    ensureCloseParen(!, ()
-                                                                listener: handleParenthesizedExpression(()
-                                                        parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
-                                                          parseExpression([)
-                                                            parsePrecedenceExpression([, 1, true)
-                                                              parseUnaryExpression([, true)
-                                                                parsePrimary([, expression)
-                                                                  parseSendOrFunctionLiteral([, expression)
-                                                                    parseSend([, expression)
-                                                                      isNextIdentifier([)
-                                                                      ensureIdentifier([, expression)
-                                                                        listener: handleIdentifier(arg, expression)
-                                                                      listener: handleNoTypeArguments(])
-                                                                      parseArgumentsOpt(arg)
-                                                                        listener: handleNoArguments(])
-                                                                      listener: handleSend(arg, ])
-                                                          listener: handleIndexedExpression(null, [, ])
-                                                    ensureCloseParen(], ()
-                                                listener: handleParenthesizedExpression(()
-                                        listener: handleNonNullAssertExpression(!)
-                                    ensureCloseParen(!, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
+                              parseParenthesizedExpressionOrRecordLiteral({)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
+                                          parseParenthesizedExpressionOrRecordLiteral(()
+                                            listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                            parseExpression(()
+                                              parsePrecedenceExpression((, 1, true)
+                                                parseUnaryExpression((, true)
+                                                  parsePrimary((, expression)
+                                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
+                                                      parseParenthesizedExpressionOrRecordLiteral(()
+                                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                                        parseExpression(()
+                                                          parsePrecedenceExpression((, 1, true)
+                                                            parseUnaryExpression((, true)
+                                                              parsePrimary((, expression)
+                                                                parseSendOrFunctionLiteral((, expression)
+                                                                  parseSend((, expression)
+                                                                    isNextIdentifier(()
+                                                                    ensureIdentifier((, expression)
+                                                                      listener: handleIdentifier(obj, expression)
+                                                                    listener: handleNoTypeArguments(!)
+                                                                    parseArgumentsOpt(obj)
+                                                                      listener: handleNoArguments(!)
+                                                                    listener: handleSend(obj, !)
+                                                            listener: handleNonNullAssertExpression(!)
+                                                        ensureCloseParen(!, ()
+                                                        listener: endParenthesizedExpression(()
+                                                parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
+                                                  parseExpression([)
+                                                    parsePrecedenceExpression([, 1, true)
+                                                      parseUnaryExpression([, true)
+                                                        parsePrimary([, expression)
+                                                          parseSendOrFunctionLiteral([, expression)
+                                                            parseSend([, expression)
+                                                              isNextIdentifier([)
+                                                              ensureIdentifier([, expression)
+                                                                listener: handleIdentifier(arg, expression)
+                                                              listener: handleNoTypeArguments(])
+                                                              parseArgumentsOpt(arg)
+                                                                listener: handleNoArguments(])
+                                                              listener: handleSend(arg, ])
+                                                  listener: handleIndexedExpression(null, [, ])
+                                            ensureCloseParen(], ()
+                                            listener: endParenthesizedExpression(()
+                                    listener: handleNonNullAssertExpression(!)
+                                ensureCloseParen(!, ()
+                                listener: endParenthesizedExpression(()
                         parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
                           parseExpression([)
                             parsePrecedenceExpression([, 1, true)

pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3_with_parens.dart.expect

@@ -10,16 +10,17 @@ beginCompilationUnit(f)
       endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
       handleAsyncModifier(null, null)
       beginBlockFunctionBody({)
-        handleIdentifier(foo, expression)
-        handleNoTypeArguments(.)
-        handleNoArguments(.)
-        handleSend(foo, .)
-        handleIdentifier(bar, expressionContinuation)
-        handleNoTypeArguments())
-        handleNoArguments())
-        handleSend(bar, ))
-        handleEndingBinaryExpression(.)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(foo, expression)
+          handleNoTypeArguments(.)
+          handleNoArguments(.)
+          handleSend(foo, .)
+          handleIdentifier(bar, expressionContinuation)
+          handleNoTypeArguments())
+          handleNoArguments())
+          handleSend(bar, ))
+          handleEndingBinaryExpression(.)
+        endParenthesizedExpression(()
         handleNonNullAssertExpression(!)
         handleIdentifier(arg, expression)
         handleNoTypeArguments(])

pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3_with_parens.dart.intertwined.expect

@@ -37,36 +37,35 @@ parseUnit(f)
                       parsePrecedenceExpression({, 1, true)
                         parseUnaryExpression({, true)
                           parsePrimary({, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral({)
-                              parseParenthesizedExpression({)
-                                parseExpressionInParenthesis({)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseSendOrFunctionLiteral((, expression)
-                                              parseSend((, expression)
-                                                isNextIdentifier(()
-                                                ensureIdentifier((, expression)
-                                                  listener: handleIdentifier(foo, expression)
-                                                listener: handleNoTypeArguments(.)
-                                                parseArgumentsOpt(foo)
-                                                  listener: handleNoArguments(.)
-                                                listener: handleSend(foo, .)
-                                        parsePrimary(., expressionContinuation)
-                                          parseSendOrFunctionLiteral(., expressionContinuation)
-                                            parseSend(., expressionContinuation)
-                                              isNextIdentifier(.)
-                                              ensureIdentifier(., expressionContinuation)
-                                                listener: handleIdentifier(bar, expressionContinuation)
-                                              listener: handleNoTypeArguments())
-                                              parseArgumentsOpt(bar)
-                                                listener: handleNoArguments())
-                                              listener: handleSend(bar, ))
-                                        listener: handleEndingBinaryExpression(.)
-                                    ensureCloseParen(bar, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
+                              parseParenthesizedExpressionOrRecordLiteral({)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseSendOrFunctionLiteral((, expression)
+                                          parseSend((, expression)
+                                            isNextIdentifier(()
+                                            ensureIdentifier((, expression)
+                                              listener: handleIdentifier(foo, expression)
+                                            listener: handleNoTypeArguments(.)
+                                            parseArgumentsOpt(foo)
+                                              listener: handleNoArguments(.)
+                                            listener: handleSend(foo, .)
+                                    parsePrimary(., expressionContinuation)
+                                      parseSendOrFunctionLiteral(., expressionContinuation)
+                                        parseSend(., expressionContinuation)
+                                          isNextIdentifier(.)
+                                          ensureIdentifier(., expressionContinuation)
+                                            listener: handleIdentifier(bar, expressionContinuation)
+                                          listener: handleNoTypeArguments())
+                                          parseArgumentsOpt(bar)
+                                            listener: handleNoArguments())
+                                          listener: handleSend(bar, ))
+                                    listener: handleEndingBinaryExpression(.)
+                                ensureCloseParen(bar, ()
+                                listener: endParenthesizedExpression(()
                         listener: handleNonNullAssertExpression(!)
                         parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
                           parseExpression([)

pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4_with_parens.dart.expect

@@ -10,19 +10,21 @@ beginCompilationUnit(f)
       endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
       handleAsyncModifier(null, null)
       beginBlockFunctionBody({)
-        handleIdentifier(foo, expression)
-        handleNoTypeArguments(!)
-        handleNoArguments(!)
-        handleSend(foo, !)
-        handleNonNullAssertExpression(!)
-        handleParenthesizedExpression(()
-        handleIdentifier(bar, expressionContinuation)
-        handleNoTypeArguments(!)
-        handleNoArguments(!)
-        handleSend(bar, !)
-        handleEndingBinaryExpression(.)
-        handleNonNullAssertExpression(!)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleIdentifier(foo, expression)
+            handleNoTypeArguments(!)
+            handleNoArguments(!)
+            handleSend(foo, !)
+            handleNonNullAssertExpression(!)
+          endParenthesizedExpression(()
+          handleIdentifier(bar, expressionContinuation)
+          handleNoTypeArguments(!)
+          handleNoArguments(!)
+          handleSend(bar, !)
+          handleEndingBinaryExpression(.)
+          handleNonNullAssertExpression(!)
+        endParenthesizedExpression(()
         handleIdentifier(arg, expression)
         handleNoTypeArguments(])
         handleNoArguments(])

pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4_with_parens.dart.intertwined.expect

@@ -37,48 +37,46 @@ parseUnit(f)
                       parsePrecedenceExpression({, 1, true)
                         parseUnaryExpression({, true)
                           parsePrimary({, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral({)
-                              parseParenthesizedExpression({)
-                                parseExpressionInParenthesis({)
-                                  parseExpressionInParenthesisRest(()
-                                    parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(()
-                                              parseParenthesizedExpression(()
-                                                parseExpressionInParenthesis(()
-                                                  parseExpressionInParenthesisRest(()
-                                                    parseExpression(()
-                                                      parsePrecedenceExpression((, 1, true)
-                                                        parseUnaryExpression((, true)
-                                                          parsePrimary((, expression)
-                                                            parseSendOrFunctionLiteral((, expression)
-                                                              parseSend((, expression)
-                                                                isNextIdentifier(()
-                                                                ensureIdentifier((, expression)
-                                                                  listener: handleIdentifier(foo, expression)
-                                                                listener: handleNoTypeArguments(!)
-                                                                parseArgumentsOpt(foo)
-                                                                  listener: handleNoArguments(!)
-                                                                listener: handleSend(foo, !)
-                                                        listener: handleNonNullAssertExpression(!)
-                                                    ensureCloseParen(!, ()
-                                                listener: handleParenthesizedExpression(()
-                                        parsePrimary(., expressionContinuation)
-                                          parseSendOrFunctionLiteral(., expressionContinuation)
-                                            parseSend(., expressionContinuation)
-                                              isNextIdentifier(.)
-                                              ensureIdentifier(., expressionContinuation)
-                                                listener: handleIdentifier(bar, expressionContinuation)
-                                              listener: handleNoTypeArguments(!)
-                                              parseArgumentsOpt(bar)
-                                                listener: handleNoArguments(!)
-                                              listener: handleSend(bar, !)
-                                        listener: handleEndingBinaryExpression(.)
-                                        listener: handleNonNullAssertExpression(!)
-                                    ensureCloseParen(!, ()
-                                listener: handleParenthesizedExpression(()
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
+                              parseParenthesizedExpressionOrRecordLiteral({)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
+                                          parseParenthesizedExpressionOrRecordLiteral(()
+                                            listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                            parseExpression(()
+                                              parsePrecedenceExpression((, 1, true)
+                                                parseUnaryExpression((, true)
+                                                  parsePrimary((, expression)
+                                                    parseSendOrFunctionLiteral((, expression)
+                                                      parseSend((, expression)
+                                                        isNextIdentifier(()
+                                                        ensureIdentifier((, expression)
+                                                          listener: handleIdentifier(foo, expression)
+                                                        listener: handleNoTypeArguments(!)
+                                                        parseArgumentsOpt(foo)
+                                                          listener: handleNoArguments(!)
+                                                        listener: handleSend(foo, !)
+                                                listener: handleNonNullAssertExpression(!)
+                                            ensureCloseParen(!, ()
+                                            listener: endParenthesizedExpression(()
+                                    parsePrimary(., expressionContinuation)
+                                      parseSendOrFunctionLiteral(., expressionContinuation)
+                                        parseSend(., expressionContinuation)
+                                          isNextIdentifier(.)
+                                          ensureIdentifier(., expressionContinuation)
+                                            listener: handleIdentifier(bar, expressionContinuation)
+                                          listener: handleNoTypeArguments(!)
+                                          parseArgumentsOpt(bar)
+                                            listener: handleNoArguments(!)
+                                          listener: handleSend(bar, !)
+                                    listener: handleEndingBinaryExpression(.)
+                                    listener: handleNonNullAssertExpression(!)
+                                ensureCloseParen(!, ()
+                                listener: endParenthesizedExpression(()
                         parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
                           parseExpression([)
                             parsePrecedenceExpression([, 1, true)

pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5_with_parens.dart.expect

@@ -10,25 +10,28 @@ beginCompilationUnit(f)
       endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
       handleAsyncModifier(null, null)
       beginBlockFunctionBody({)
-        handleIdentifier(foo, expression)
-        handleNoTypeArguments(.)
-        handleNoArguments(.)
-        handleSend(foo, .)
-        handleIdentifier(bar, expressionContinuation)
-        handleNoTypeArguments(!)
-        handleNoArguments(!)
-        handleSend(bar, !)
-        handleEndingBinaryExpression(.)
-        handleNonNullAssertExpression(!)
-        handleParenthesizedExpression(()
-        handleIdentifier(arg, expression)
-        handleNoTypeArguments(])
-        handleNoArguments(])
-        handleSend(arg, ])
-        handleIndexedExpression(null, [, ])
-        handleParenthesizedExpression(()
-        handleNonNullAssertExpression(!)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleIdentifier(foo, expression)
+              handleNoTypeArguments(.)
+              handleNoArguments(.)
+              handleSend(foo, .)
+              handleIdentifier(bar, expressionContinuation)
+              handleNoTypeArguments(!)
+              handleNoArguments(!)
+              handleSend(bar, !)
+              handleEndingBinaryExpression(.)
+              handleNonNullAssertExpression(!)
+            endParenthesizedExpression(()
+            handleIdentifier(arg, expression)
+            handleNoTypeArguments(])
+            handleNoArguments(])
+            handleSend(arg, ])
+            handleIndexedExpression(null, [, ])
+          endParenthesizedExpression(()
+          handleNonNullAssertExpression(!)
+        endParenthesizedExpression(()
         handleIdentifier(arg2, expression)
         handleNoTypeArguments(])
         handleNoArguments(])