diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/forwarding_listener.dart b/pkg/_fe_analyzer_shared/lib/src/parser/forwarding_listener.dart
index a10e793..9380289 100644
--- a/pkg/_fe_analyzer_shared/lib/src/parser/forwarding_listener.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/parser/forwarding_listener.dart
@@ -1570,6 +1570,11 @@
   }
 
   @override
+  void handleNamedRecordField(Token colon) {
+    listener?.handleNamedRecordField(colon);
+  }
+
+  @override
   void handleNamedMixinApplicationWithClause(Token withKeyword) {
     listener?.handleNamedMixinApplicationWithClause(withKeyword);
   }
@@ -1685,8 +1690,18 @@
   }
 
   @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
diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/identifier_context.dart b/pkg/_fe_analyzer_shared/lib/src/parser/identifier_context.dart
index 5236661..8151611 100644
--- a/pkg/_fe_analyzer_shared/lib/src/parser/identifier_context.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/parser/identifier_context.dart
@@ -255,6 +255,12 @@
   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 =
diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/identifier_context_impl.dart b/pkg/_fe_analyzer_shared/lib/src/parser/identifier_context_impl.dart
index 979d161..9793d5a 100644
--- a/pkg/_fe_analyzer_shared/lib/src/parser/identifier_context_impl.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/parser/identifier_context_impl.dart
@@ -1020,6 +1020,42 @@
   }
 }
 
+/// 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 {
diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/listener.dart b/pkg/_fe_analyzer_shared/lib/src/parser/listener.dart
index 107f7da..10b0ee7 100644
--- a/pkg/_fe_analyzer_shared/lib/src/parser/listener.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/parser/listener.dart
@@ -1692,6 +1692,10 @@
     logEvent("NamedArgument");
   }
 
+  void handleNamedRecordField(Token colon) {
+    logEvent("NamedRecordField");
+  }
+
   void beginNewExpression(Token token) {}
 
   void endNewExpression(Token token) {
@@ -1746,10 +1750,19 @@
     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");
   }
 
diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart b/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart
index efd5fc2..f5b2825 100644
--- a/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart
@@ -5852,7 +5852,7 @@
         // 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 @@
     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 @@
     }
     bool old = mayParseFunctionExpressions;
     mayParseFunctionExpressions = true;
-    token = parseParenthesizedExpression(token);
+    token = parseParenthesizedExpressionOrRecordLiteral(token);
     mayParseFunctionExpressions = old;
     return token;
   }
@@ -5919,15 +5921,59 @@
     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) {
diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/stack_listener.dart b/pkg/_fe_analyzer_shared/lib/src/parser/stack_listener.dart
index e3de0f9..f4a592f 100644
--- a/pkg/_fe_analyzer_shared/lib/src/parser/stack_listener.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/parser/stack_listener.dart
@@ -431,7 +431,12 @@
   }
 
   @override
-  void handleParenthesizedExpression(Token token) {
+  void endRecordLiteral(Token token, int count) {
+    debugEvent("RecordLiteral");
+  }
+
+  @override
+  void endParenthesizedExpression(Token token) {
     debugEvent("ParenthesizedExpression");
   }
 
diff --git a/pkg/analysis_server/test/lsp/type_definition_test.dart b/pkg/analysis_server/test/lsp/type_definition_test.dart
index 8d78416..b363207 100644
--- a/pkg/analysis_server/test/lsp/type_definition_test.dart
+++ b/pkg/analysis_server/test/lsp/type_definition_test.dart
@@ -123,7 +123,7 @@
   Future<void> test_parameter() async {
     final contents = '''
 void f(String a) {
-  void f([['te^st']]);
+  f([['te^st']]);
 }
 ''';
 
@@ -135,7 +135,7 @@
   Future<void> test_parameterName() async {
     final contents = '''
 void f({String a}) {
-  void f([[a^]]: 'test');
+  f([[a^]]: 'test');
 }
 ''';
 
diff --git a/pkg/analyzer/lib/src/dart/analysis/driver.dart b/pkg/analyzer/lib/src/dart/analysis/driver.dart
index e0e7658..7eb930f 100644
--- a/pkg/analyzer/lib/src/dart/analysis/driver.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/driver.dart
@@ -85,7 +85,7 @@
 /// TODO(scheglov) Clean up the list of implicitly analyzed files.
 class AnalysisDriver implements AnalysisDriverGeneric {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 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.
diff --git a/pkg/analyzer/lib/src/dart/analysis/experiments.g.dart b/pkg/analyzer/lib/src/dart/analysis/experiments.g.dart
index 5bbbd36..9d73f80 100644
--- a/pkg/analyzer/lib/src/dart/analysis/experiments.g.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/experiments.g.dart
@@ -33,6 +33,7 @@
   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 @@
   /// 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 @@
     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 @@
   );
 
   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 @@
   );
 
   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 @@
   );
 
   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 @@
   );
 
   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 @@
   );
 
   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 @@
   );
 
   static final variance = ExperimentalFeature(
-    index: 20,
+    index: 21,
     enableString: EnableString.variance,
     isEnabledByDefault: IsEnabledByDefault.variance,
     isExpired: IsExpired.variance,
@@ -371,6 +385,9 @@
   /// 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 @@
   /// 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 @@
   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);
 
diff --git a/pkg/analyzer/lib/src/fasta/ast_builder.dart b/pkg/analyzer/lib/src/fasta/ast_builder.dart
index 9a32845..44e0f2b 100644
--- a/pkg/analyzer/lib/src/fasta/ast_builder.dart
+++ b/pkg/analyzer/lib/src/fasta/ast_builder.dart
@@ -2346,6 +2346,16 @@
   }
 
   @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));
     assert(optional(';', semicolon));
@@ -2396,6 +2406,29 @@
   }
 
   @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));
     debugEvent("RedirectingFactoryBody");
@@ -3932,6 +3965,10 @@
   }
 
   @override
+  // TODO: Handle directly.
+  void handleNamedRecordField(Token colon) => handleNamedArgument(colon);
+
+  @override
   void handleNativeClause(Token nativeToken, bool hasName) {
     debugEvent("NativeClause");
 
@@ -4041,17 +4078,7 @@
   @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
diff --git a/pkg/analyzer/tool/summary/mini_ast.dart b/pkg/analyzer/tool/summary/mini_ast.dart
index 429cb67..d07bb77 100644
--- a/pkg/analyzer/tool/summary/mini_ast.dart
+++ b/pkg/analyzer/tool/summary/mini_ast.dart
@@ -538,6 +538,10 @@
   }
 
   @override
+  // TODO: Handle directly.
+  void handleNamedRecordField(Token colon) => handleNamedArgument(colon);
+
+  @override
   void handleNativeClause(Token nativeToken, bool hasName) {
     debugEvent("NativeClause");
     if (hasName) {
diff --git a/pkg/front_end/lib/src/api_prototype/experimental_flags_generated.dart b/pkg/front_end/lib/src/api_prototype/experimental_flags_generated.dart
index 3c5892a..bac8946 100644
--- a/pkg/front_end/lib/src/api_prototype/experimental_flags_generated.dart
+++ b/pkg/front_end/lib/src/api_prototype/experimental_flags_generated.dart
@@ -171,6 +171,14 @@
       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 @@
   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 @@
           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 @@
       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 @@
   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,
diff --git a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
index 930245e..261b444 100644
--- a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
@@ -69,7 +69,13 @@
 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 @@
   }
 
   @override
-  void handleParenthesizedExpression(Token token) {
+  void endParenthesizedExpression(Token token) {
     assert(checkState(token, [
       unionOfKinds([
         ValueKinds.Expression,
@@ -3951,6 +3957,26 @@
     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;
@@ -5950,6 +5976,10 @@
   }
 
   @override
+  // TODO: Handle directly.
+  void handleNamedRecordField(Token colon) => handleNamedArgument(colon);
+
+  @override
   void endFunctionName(Token beginToken, Token token) {
     debugEvent("FunctionName");
     Identifier name = pop() as Identifier;
diff --git a/pkg/front_end/lib/src/fasta/kernel/macro/annotation_parser.dart b/pkg/front_end/lib/src/fasta/kernel/macro/annotation_parser.dart
index 4984f92..251e042 100644
--- a/pkg/front_end/lib/src/fasta/kernel/macro/annotation_parser.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/macro/annotation_parser.dart
@@ -319,6 +319,10 @@
   }
 
   @override
+  // TODO: Handle directly.
+  void handleNamedRecordField(Token colon) => handleNamedArgument(colon);
+
+  @override
   void handleLiteralNull(Token token) {
     push(new _PrimitiveValueNode(null));
   }
@@ -1917,7 +1921,17 @@
   }
 
   @override
-  void handleParenthesizedExpression(Token token) {
+  void beginParenthesizedExpressionOrRecordLiteral(Token token) {
+    _unhandled();
+  }
+
+  @override
+  void endRecordLiteral(Token token, int count) {
+    _unhandled();
+  }
+
+  @override
+  void endParenthesizedExpression(Token token) {
     _unhandled();
   }
 
diff --git a/pkg/front_end/lib/src/fasta/source/diet_listener.dart b/pkg/front_end/lib/src/fasta/source/diet_listener.dart
index 16e8716..0a957b4 100644
--- a/pkg/front_end/lib/src/fasta/source/diet_listener.dart
+++ b/pkg/front_end/lib/src/fasta/source/diet_listener.dart
@@ -194,6 +194,12 @@
   }
 
   @override
+  void handleNamedRecordField(Token colon) {
+    debugEvent("NamedRecordField");
+    pop(); // Named record field name.
+  }
+
+  @override
   void handleClassWithClause(Token withKeyword) {
     debugEvent("ClassWithClause");
   }
diff --git a/pkg/front_end/lib/src/fasta/source/outline_builder.dart b/pkg/front_end/lib/src/fasta/source/outline_builder.dart
index d09d0b6..bb803ff 100644
--- a/pkg/front_end/lib/src/fasta/source/outline_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/outline_builder.dart
@@ -2010,6 +2010,13 @@
   }
 
   @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) {
     debugEvent("endNamedMixinApplication");
diff --git a/pkg/front_end/lib/src/fasta/util/parser_ast.dart b/pkg/front_end/lib/src/fasta/util/parser_ast.dart
index f30a4a8..90a51d2 100644
--- a/pkg/front_end/lib/src/fasta/util/parser_ast.dart
+++ b/pkg/front_end/lib/src/fasta/util/parser_ast.dart
@@ -1553,6 +1553,10 @@
             (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";
         }
diff --git a/pkg/front_end/lib/src/fasta/util/parser_ast_helper.dart b/pkg/front_end/lib/src/fasta/util/parser_ast_helper.dart
index 7006708..2e9b882 100644
--- a/pkg/front_end/lib/src/fasta/util/parser_ast_helper.dart
+++ b/pkg/front_end/lib/src/fasta/util/parser_ast_helper.dart
@@ -2294,6 +2294,13 @@
   }
 
   @override
+  void handleNamedRecordField(Token colon) {
+    NamedRecordFieldHandle data =
+        new NamedRecordFieldHandle(ParserAstType.HANDLE, colon: colon);
+    seen(data);
+  }
+
+  @override
   void beginNewExpression(Token token) {
     NewExpressionBegin data =
         new NewExpressionBegin(ParserAstType.BEGIN, token: token);
@@ -2383,9 +2390,24 @@
   }
 
   @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 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 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
diff --git a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_00.dart.expect b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_00.dart.expect
index ee69b69..2476340 100644
--- a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_00.dart.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_00.dart.expect
@@ -21,9 +21,10 @@
       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 @@
       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, {, })
diff --git a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_00.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_00.dart.intertwined.expect
index 6bebae6..bc757e9 100644
--- a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_00.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_00.dart.intertwined.expect
@@ -42,19 +42,18 @@
                                 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 @@
                                 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(;)
diff --git a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_04.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_04.dart.intertwined.expect
index 076e9d1..9bab235 100644
--- a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_04.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_04.dart.intertwined.expect
@@ -50,7 +50,7 @@
                                       parsePrecedenceExpression((, 1, true)
                                         parseUnaryExpression((, true)
                                           parsePrimary((, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(()
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(()
                                                 listener: beginFunctionExpression(()
diff --git a/pkg/front_end/parser_testcases/error_recovery/extension_member_contributor_test_completion.dart.expect b/pkg/front_end/parser_testcases/error_recovery/extension_member_contributor_test_completion.dart.expect
index 19c202d..1fbe01a 100644
--- a/pkg/front_end/parser_testcases/error_recovery/extension_member_contributor_test_completion.dart.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/extension_member_contributor_test_completion.dart.expect
@@ -187,16 +187,17 @@
           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, })
diff --git a/pkg/front_end/parser_testcases/error_recovery/extension_member_contributor_test_completion.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/extension_member_contributor_test_completion.dart.intertwined.expect
index bdae2a2..c3effb6 100644
--- a/pkg/front_end/parser_testcases/error_recovery/extension_member_contributor_test_completion.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/extension_member_contributor_test_completion.dart.intertwined.expect
@@ -328,36 +328,35 @@
                       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(}, })
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_42267.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_42267.dart.intertwined.expect
index 0018e7b..ef58d44 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_42267.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_42267.dart.intertwined.expect
@@ -99,7 +99,7 @@
                                       parsePrecedenceExpression((, 1, true)
                                         parseUnaryExpression((, true)
                                           parsePrimary((, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(()
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(()
                                                 listener: beginFunctionExpression(()
@@ -250,7 +250,7 @@
                                       parsePrecedenceExpression((, 1, true)
                                         parseUnaryExpression((, true)
                                           parsePrimary((, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(()
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(()
                                                 listener: beginFunctionExpression(()
@@ -403,7 +403,7 @@
                                       parsePrecedenceExpression((, 1, true)
                                         parseUnaryExpression((, true)
                                           parsePrimary((, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(()
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(()
                                                 listener: beginFunctionExpression(()
diff --git a/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.expect b/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.expect
index 902c6a8..85b020f 100644
--- a/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.expect
@@ -832,14 +832,15 @@
               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 @@
               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 @@
               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 @@
               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 @@
                 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 @@
               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 @@
                 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 @@
                 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(+)
diff --git a/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.intertwined.expect
index 06dc2d8..df7d6f2 100644
--- a/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.intertwined.expect
@@ -883,32 +883,31 @@
                               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 @@
                               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 @@
                                     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 @@
                               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 @@
                               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 @@
                                 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 @@
                               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 @@
                               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)
diff --git a/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.expect b/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.expect
index 02db7c4..06ce561 100644
--- a/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.expect
@@ -798,14 +798,15 @@
         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 @@
         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 @@
         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 @@
         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 @@
           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 @@
         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 @@
           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 @@
           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(+)
diff --git a/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.intertwined.expect
index 8b1d7ab..c9a7ba8 100644
--- a/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.intertwined.expect
@@ -836,32 +836,31 @@
                       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 @@
                       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 @@
                             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 @@
                       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 @@
                       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 @@
                         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 @@
                       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 @@
                       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)
diff --git a/pkg/front_end/parser_testcases/general/augment_super.dart.expect b/pkg/front_end/parser_testcases/general/augment_super.dart.expect
index 6eeeb58..0068277 100644
--- a/pkg/front_end/parser_testcases/general/augment_super.dart.expect
+++ b/pkg/front_end/parser_testcases/general/augment_super.dart.expect
@@ -220,12 +220,13 @@
           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 @@
           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 @@
                 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 @@
                 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)
diff --git a/pkg/front_end/parser_testcases/general/augment_super.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/augment_super.dart.intertwined.expect
index 4cb40bd..5e67d92 100644
--- a/pkg/front_end/parser_testcases/general/augment_super.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/augment_super.dart.intertwined.expect
@@ -85,27 +85,26 @@
                       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 @@
                       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 @@
                               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 @@
                               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)
diff --git a/pkg/front_end/parser_testcases/general/chained_call_05.dart.expect b/pkg/front_end/parser_testcases/general/chained_call_05.dart.expect
index 8b0e034..ab99785 100644
--- a/pkg/front_end/parser_testcases/general/chained_call_05.dart.expect
+++ b/pkg/front_end/parser_testcases/general/chained_call_05.dart.expect
@@ -19,12 +19,13 @@
       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(>)
diff --git a/pkg/front_end/parser_testcases/general/chained_call_05.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/chained_call_05.dart.intertwined.expect
index 5434b21..9e8ca34 100644
--- a/pkg/front_end/parser_testcases/general/chained_call_05.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/chained_call_05.dart.intertwined.expect
@@ -48,29 +48,28 @@
                       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(>)
diff --git a/pkg/front_end/parser_testcases/general/chained_call_06.dart.expect b/pkg/front_end/parser_testcases/general/chained_call_06.dart.expect
index a754bf0..a60ee4d 100644
--- a/pkg/front_end/parser_testcases/general/chained_call_06.dart.expect
+++ b/pkg/front_end/parser_testcases/general/chained_call_06.dart.expect
@@ -19,17 +19,18 @@
       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(>)
diff --git a/pkg/front_end/parser_testcases/general/chained_call_06.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/chained_call_06.dart.intertwined.expect
index f308d99..e2b9b0c 100644
--- a/pkg/front_end/parser_testcases/general/chained_call_06.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/chained_call_06.dart.intertwined.expect
@@ -48,40 +48,39 @@
                       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(>)
diff --git a/pkg/front_end/parser_testcases/general/function_expression.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/function_expression.dart.intertwined.expect
index 4a83b37..1cb2ded 100644
--- a/pkg/front_end/parser_testcases/general/function_expression.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/function_expression.dart.intertwined.expect
@@ -37,7 +37,7 @@
                       parsePrecedenceExpression({, 1, true)
                         parseUnaryExpression({, true)
                           parsePrimary({, expression)
-                            parseParenthesizedExpressionOrFunctionLiteral({)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
                               listener: handleNoTypeVariables(()
                               parseFunctionExpression({)
                                 listener: beginFunctionExpression(()
diff --git a/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.expect b/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.expect
index bfa32fb..c0a3ef2 100644
--- a/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.expect
+++ b/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.expect
@@ -578,11 +578,12 @@
           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, (, ))
diff --git a/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.intertwined.expect
index 918b3ca..d32578d 100644
--- a/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.intertwined.expect
@@ -1032,25 +1032,24 @@
                                     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, (, ))
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_01.dart.expect b/pkg/front_end/parser_testcases/general/issue_45848_01.dart.expect
index 63a4760..bcefa47 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_01.dart.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_01.dart.expect
@@ -102,17 +102,18 @@
             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, (, ))
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_01.dart.intertwined.expect
index 762eb6c..d9c1bcc 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_01.dart.intertwined.expect
@@ -223,34 +223,33 @@
                                       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 @@
                                       parsePrecedenceExpression(,, 1, true)
                                         parseUnaryExpression(,, true)
                                           parsePrimary(,, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(,)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(,)
                                                 listener: beginFunctionExpression(()
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_01.equivalence_info b/pkg/front_end/parser_testcases/general/issue_45848_01.equivalence_info
index 7bb0fd9..775e230 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_01.equivalence_info
+++ b/pkg/front_end/parser_testcases/general/issue_45848_01.equivalence_info
@@ -4,4 +4,5 @@
 filters:
   - ignoreListenerArguments
 ignored:
-  - handleParenthesizedExpression
+  - beginParenthesizedExpressionOrRecordLiteral
+  - endParenthesizedExpression
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_01_prime.dart.expect b/pkg/front_end/parser_testcases/general/issue_45848_01_prime.dart.expect
index 20a4b28..b4fb437 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_01_prime.dart.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_01_prime.dart.expect
@@ -92,28 +92,30 @@
         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, (, ))
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_01_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_01_prime.dart.intertwined.expect
index 6649435..a488a13 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_01_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_01_prime.dart.intertwined.expect
@@ -195,71 +195,69 @@
                                       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 @@
                                       parsePrecedenceExpression(,, 1, true)
                                         parseUnaryExpression(,, true)
                                           parsePrimary(,, expression)
-                                            parseParenthesizedExpressionOrFunctionLiteral(,)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(,)
                                                 listener: beginFunctionExpression(()
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_02.dart.expect b/pkg/front_end/parser_testcases/general/issue_45848_02.dart.expect
index f217da9..d2f0ce1 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_02.dart.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_02.dart.expect
@@ -104,17 +104,18 @@
           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, ;)
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_02.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_02.dart.intertwined.expect
index dd24930..bbb86fc 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_02.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_02.dart.intertwined.expect
@@ -229,34 +229,33 @@
                                         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, ;)
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_02.equivalence_info b/pkg/front_end/parser_testcases/general/issue_45848_02.equivalence_info
index 786165c..50e2c48 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_02.equivalence_info
+++ b/pkg/front_end/parser_testcases/general/issue_45848_02.equivalence_info
@@ -4,4 +4,5 @@
 filters:
   - ignoreListenerArguments
 ignored:
-  - handleParenthesizedExpression
+  - beginParenthesizedExpressionOrRecordLiteral
+  - endParenthesizedExpression
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_02_prime.dart.expect b/pkg/front_end/parser_testcases/general/issue_45848_02_prime.dart.expect
index ab3fe72..ee4ab3b 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_02_prime.dart.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_02_prime.dart.expect
@@ -92,30 +92,32 @@
         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, ;)
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_02_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_02_prime.dart.intertwined.expect
index cf4975c..974c9dc 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_02_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_02_prime.dart.intertwined.expect
@@ -195,39 +195,38 @@
                                       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 @@
                                         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, ;)
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_03.dart.expect b/pkg/front_end/parser_testcases/general/issue_45848_03.dart.expect
index 911ef38..812cb1b 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_03.dart.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_03.dart.expect
@@ -111,29 +111,31 @@
             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, ;)
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_03.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_03.dart.intertwined.expect
index 98b3ef5..9a37bbb 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_03.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_03.dart.intertwined.expect
@@ -235,66 +235,64 @@
                                       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, ;)
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_03.equivalence_info b/pkg/front_end/parser_testcases/general/issue_45848_03.equivalence_info
index e17dc1c..7754efb 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_03.equivalence_info
+++ b/pkg/front_end/parser_testcases/general/issue_45848_03.equivalence_info
@@ -4,4 +4,5 @@
 filters:
   - ignoreListenerArguments
 ignored:
-  - handleParenthesizedExpression
+  - beginParenthesizedExpressionOrRecordLiteral
+  - endParenthesizedExpression
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_03_prime.dart.expect b/pkg/front_end/parser_testcases/general/issue_45848_03_prime.dart.expect
index 986780c..b2347f2 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_03_prime.dart.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_03_prime.dart.expect
@@ -101,40 +101,43 @@
         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, ;)
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_03_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_03_prime.dart.intertwined.expect
index c0c86e7..388720f 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_03_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_03_prime.dart.intertwined.expect
@@ -207,103 +207,100 @@
                                       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, ;)
diff --git a/pkg/front_end/parser_testcases/general/issue_47008_01.dart.expect b/pkg/front_end/parser_testcases/general/issue_47008_01.dart.expect
index c08a421..41ad8b3 100644
--- a/pkg/front_end/parser_testcases/general/issue_47008_01.dart.expect
+++ b/pkg/front_end/parser_testcases/general/issue_47008_01.dart.expect
@@ -35,8 +35,9 @@
           endBinaryExpression(<)
           handleLiteralInt(1)
           beginBinaryExpression(>>)
-            handleLiteralInt(2)
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleLiteralInt(2)
+            endParenthesizedExpression(()
           endBinaryExpression(>>)
         endArguments(3, (, ))
         handleSend(a, ;)
diff --git a/pkg/front_end/parser_testcases/general/issue_47008_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_47008_01.dart.intertwined.expect
index cb4e3f7..45bab8d 100644
--- a/pkg/front_end/parser_testcases/general/issue_47008_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_47008_01.dart.intertwined.expect
@@ -112,18 +112,17 @@
                                         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, ;)
diff --git a/pkg/front_end/parser_testcases/general/issue_47008_02.dart.expect b/pkg/front_end/parser_testcases/general/issue_47008_02.dart.expect
index db45d9b..2f64398 100644
--- a/pkg/front_end/parser_testcases/general/issue_47008_02.dart.expect
+++ b/pkg/front_end/parser_testcases/general/issue_47008_02.dart.expect
@@ -45,8 +45,9 @@
           endBinaryExpression(<)
           handleLiteralInt(1)
           beginBinaryExpression(>>>)
-            handleLiteralInt(2)
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleLiteralInt(2)
+            endParenthesizedExpression(()
           endBinaryExpression(>>>)
         endArguments(4, (, ))
         handleSend(a, ;)
diff --git a/pkg/front_end/parser_testcases/general/issue_47008_02.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_47008_02.dart.intertwined.expect
index 075efbb..0cfb7ed 100644
--- a/pkg/front_end/parser_testcases/general/issue_47008_02.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_47008_02.dart.intertwined.expect
@@ -139,18 +139,17 @@
                                         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, ;)
diff --git a/pkg/front_end/parser_testcases/general/issue_47009_01.dart.expect b/pkg/front_end/parser_testcases/general/issue_47009_01.dart.expect
index 2842fa7..5e66939 100644
--- a/pkg/front_end/parser_testcases/general/issue_47009_01.dart.expect
+++ b/pkg/front_end/parser_testcases/general/issue_47009_01.dart.expect
@@ -28,8 +28,9 @@
           handleNoArguments(>)
           handleSend(as, >)
           beginBinaryExpression(>)
-            handleLiteralInt(1)
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleLiteralInt(1)
+            endParenthesizedExpression(()
           endBinaryExpression(>)
         endArguments(2, (, ))
         handleSend(a, ;)
diff --git a/pkg/front_end/parser_testcases/general/issue_47009_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_47009_01.dart.intertwined.expect
index abc7128..5136298 100644
--- a/pkg/front_end/parser_testcases/general/issue_47009_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_47009_01.dart.intertwined.expect
@@ -94,18 +94,17 @@
                                         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, ;)
diff --git a/pkg/front_end/parser_testcases/general/issue_47009_02.dart.expect b/pkg/front_end/parser_testcases/general/issue_47009_02.dart.expect
index 398a61b..f02fcc7 100644
--- a/pkg/front_end/parser_testcases/general/issue_47009_02.dart.expect
+++ b/pkg/front_end/parser_testcases/general/issue_47009_02.dart.expect
@@ -38,8 +38,9 @@
           handleNoArguments(>>)
           handleSend(as, >>)
           beginBinaryExpression(>>)
-            handleLiteralInt(1)
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleLiteralInt(1)
+            endParenthesizedExpression(()
           endBinaryExpression(>>)
         endArguments(3, (, ))
         handleSend(a, ;)
diff --git a/pkg/front_end/parser_testcases/general/issue_47009_02.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_47009_02.dart.intertwined.expect
index d752307..42a1ecf 100644
--- a/pkg/front_end/parser_testcases/general/issue_47009_02.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_47009_02.dart.intertwined.expect
@@ -121,18 +121,17 @@
                                         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, ;)
diff --git a/pkg/front_end/parser_testcases/general/issue_47009_03.dart.expect b/pkg/front_end/parser_testcases/general/issue_47009_03.dart.expect
index f6b6a1f..74215b8 100644
--- a/pkg/front_end/parser_testcases/general/issue_47009_03.dart.expect
+++ b/pkg/front_end/parser_testcases/general/issue_47009_03.dart.expect
@@ -48,8 +48,9 @@
           handleNoArguments(>>>)
           handleSend(as, >>>)
           beginBinaryExpression(>>>)
-            handleLiteralInt(1)
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleLiteralInt(1)
+            endParenthesizedExpression(()
           endBinaryExpression(>>>)
         endArguments(4, (, ))
         handleSend(a, ;)
diff --git a/pkg/front_end/parser_testcases/general/issue_47009_03.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_47009_03.dart.intertwined.expect
index 935f19a..4194aa5 100644
--- a/pkg/front_end/parser_testcases/general/issue_47009_03.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_47009_03.dart.intertwined.expect
@@ -148,18 +148,17 @@
                                         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, ;)
diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_05.dart.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_05.dart.expect
index eb681bb..6f4e90c 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_05.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_05.dart.expect
@@ -19,16 +19,17 @@
       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 @@
         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(>)
diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_05.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_05.dart.intertwined.expect
index 1c24308c..ea105b8 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_05.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_05.dart.intertwined.expect
@@ -48,33 +48,32 @@
                       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 @@
                       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(>)
diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_06.dart.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_06.dart.expect
index 4796374..fc88f50 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_06.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_06.dart.expect
@@ -19,18 +19,19 @@
       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 @@
         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(>)
diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_06.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_06.dart.intertwined.expect
index 3e3a9f3..91a81dd 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_06.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_06.dart.intertwined.expect
@@ -48,41 +48,40 @@
                       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 @@
                       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(>)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39697_prime.dart.expect b/pkg/front_end/parser_testcases/nnbd/issue_39697_prime.dart.expect
index 6185fd0..c67ca5e 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39697_prime.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39697_prime.dart.expect
@@ -10,27 +10,28 @@
       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(;)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39697_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39697_prime.dart.intertwined.expect
index e244fe9..571fd2c 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39697_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39697_prime.dart.intertwined.expect
@@ -28,60 +28,59 @@
               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)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39723_prime.dart.expect b/pkg/front_end/parser_testcases/nnbd/issue_39723_prime.dart.expect
index 5ef701e..ba5ff5d 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39723_prime.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39723_prime.dart.expect
@@ -65,12 +65,13 @@
             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 @@
         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(;)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39723_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39723_prime.dart.intertwined.expect
index 82758c4..22a3b76 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39723_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39723_prime.dart.intertwined.expect
@@ -153,26 +153,25 @@
                       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 @@
                       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 @@
                       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 @@
                       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)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime2.dart.expect b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime2.dart.expect
index 6dda6e9..d0437e9 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime2.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime2.dart.expect
@@ -112,12 +112,13 @@
             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(>)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime2.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime2.dart.intertwined.expect
index 56af9fb..23982db 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime2.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime2.dart.intertwined.expect
@@ -259,26 +259,25 @@
                       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(>)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional.dart.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional.dart.expect
index ba8a1cc..bd40051 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional.dart.expect
@@ -144,21 +144,23 @@
         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, {, })
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional.dart.intertwined.expect
index ea5feb9..15b1d71 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional.dart.intertwined.expect
@@ -540,64 +540,62 @@
                           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(;)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_no_type_arguments.dart.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_no_type_arguments.dart.expect
index 9fe3525..0a1c3d3 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_no_type_arguments.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_no_type_arguments.dart.expect
@@ -53,11 +53,12 @@
         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: ;}], ;, ;)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_no_type_arguments.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_no_type_arguments.dart.intertwined.expect
index 243dd75..4c3f2b3 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_no_type_arguments.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_no_type_arguments.dart.intertwined.expect
@@ -126,25 +126,24 @@
                           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: :}])
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime.dart.expect b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime.dart.expect
index b6813cd..e620851 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime.dart.expect
@@ -20,17 +20,18 @@
       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(<)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime.dart.intertwined.expect
index b3f8cc3..645f9a0 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime.dart.intertwined.expect
@@ -48,37 +48,36 @@
                       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)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime2.dart.expect b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime2.dart.expect
index 3026351..cb9f057 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime2.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime2.dart.expect
@@ -20,16 +20,17 @@
       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(<)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime2.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime2.dart.intertwined.expect
index 20ab822..adf5186 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime2.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime2.dart.intertwined.expect
@@ -48,36 +48,35 @@
                       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)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_41177.dart.expect b/pkg/front_end/parser_testcases/nnbd/issue_41177.dart.expect
index cafb81f..e60b648 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_41177.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_41177.dart.expect
@@ -55,12 +55,13 @@
         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 @@
           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)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_41177.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_41177.dart.intertwined.expect
index 4be754e..1ad767b 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_41177.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_41177.dart.intertwined.expect
@@ -176,26 +176,25 @@
                       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 @@
                       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)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_42621.dart.expect b/pkg/front_end/parser_testcases/nnbd/issue_42621.dart.expect
index 1931d06..599b09e 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_42621.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_42621.dart.expect
@@ -202,20 +202,21 @@
             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(..)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_42621.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_42621.dart.intertwined.expect
index c621fc7..65386e2 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_42621.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_42621.dart.intertwined.expect
@@ -417,44 +417,43 @@
                         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())
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_47020.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_47020.dart.intertwined.expect
index 06f70a8..d6bc6c8b 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_47020.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_47020.dart.intertwined.expect
@@ -35,7 +35,7 @@
                     parsePrecedenceExpression(=, 1, false)
                       parseUnaryExpression(=, false)
                         parsePrimary(=, expression)
-                          parseParenthesizedExpressionOrFunctionLiteral(=)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
                             parseFunctionExpression(=)
                               parseFormalParametersRequiredOpt(=, MemberKind.Local)
                                 parseFormalParametersRest((, MemberKind.Local)
@@ -87,7 +87,7 @@
                           parsePrecedenceExpression(=, 1, true)
                             parseUnaryExpression(=, true)
                               parsePrimary(=, expression)
-                                parseParenthesizedExpressionOrFunctionLiteral(=)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
                                   listener: handleNoTypeVariables(()
                                   parseFunctionExpression(=)
                                     listener: beginFunctionExpression(()
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_48999.equivalence_info b/pkg/front_end/parser_testcases/nnbd/issue_48999.equivalence_info
index f638038..194fa58 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_48999.equivalence_info
+++ b/pkg/front_end/parser_testcases/nnbd/issue_48999.equivalence_info
@@ -4,4 +4,5 @@
 filters:
   - ignoreListenerArguments
 ignored:
-  - handleParenthesizedExpression
+  - beginParenthesizedExpressionOrRecordLiteral
+  - endParenthesizedExpression
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_48999_prime.dart.expect b/pkg/front_end/parser_testcases/nnbd/issue_48999_prime.dart.expect
index de2181f..e835c1f 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_48999_prime.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_48999_prime.dart.expect
@@ -27,17 +27,18 @@
         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 @@
         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, ))
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_48999_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_48999_prime.dart.intertwined.expect
index 85d13b9..0cf156d 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_48999_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_48999_prime.dart.intertwined.expect
@@ -86,34 +86,33 @@
                                                   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 @@
                                                   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(')
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_49132.equivalence_info b/pkg/front_end/parser_testcases/nnbd/issue_49132.equivalence_info
index b0a9777..e1736c5 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_49132.equivalence_info
+++ b/pkg/front_end/parser_testcases/nnbd/issue_49132.equivalence_info
@@ -4,4 +4,5 @@
 filters:
   - ignoreListenerArguments
 ignored:
-  - handleParenthesizedExpression
+  - beginParenthesizedExpressionOrRecordLiteral
+  - endParenthesizedExpression
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_49132_prime.dart.expect b/pkg/front_end/parser_testcases/nnbd/issue_49132_prime.dart.expect
index 73c3ccc..515c8e1 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_49132_prime.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_49132_prime.dart.expect
@@ -46,17 +46,18 @@
                 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 @@
                 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 @@
                 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 @@
                 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 @@
                 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 @@
                 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 @@
                 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 @@
                 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 @@
                 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 @@
                 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 @@
                 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 @@
                 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 @@
                 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 @@
                 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 @@
                 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 @@
                 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, :, {)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_49132_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_49132_prime.dart.intertwined.expect
index 8875225..f0cf0da 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_49132_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_49132_prime.dart.intertwined.expect
@@ -95,34 +95,33 @@
                             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 @@
                             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 @@
                             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 @@
                             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 @@
                             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 @@
                             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 @@
                             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 @@
                             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 @@
                             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 @@
                             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 @@
                             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 @@
                             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 @@
                             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 @@
                             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 @@
                             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 @@
                             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, :, {)
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex_with_parens.dart.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex_with_parens.dart.expect
index d59a18a..847a1e4 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex_with_parens.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex_with_parens.dart.expect
@@ -10,16 +10,17 @@
       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([)
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex_with_parens.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex_with_parens.dart.intertwined.expect
index 779bb69..d293a8a9 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex_with_parens.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex_with_parens.dart.intertwined.expect
@@ -37,36 +37,35 @@
                       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)
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2_with_parens.dart.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2_with_parens.dart.expect
index fed0fd1..6dd7657 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2_with_parens.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2_with_parens.dart.expect
@@ -10,20 +10,23 @@
       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(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2_with_parens.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2_with_parens.dart.intertwined.expect
index 40b8536..0b33562 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2_with_parens.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2_with_parens.dart.intertwined.expect
@@ -37,62 +37,59 @@
                       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)
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3_with_parens.dart.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3_with_parens.dart.expect
index 6bbea90..26e62f1 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3_with_parens.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3_with_parens.dart.expect
@@ -10,16 +10,17 @@
       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(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3_with_parens.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3_with_parens.dart.intertwined.expect
index 8059ae9..8b34fab 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3_with_parens.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3_with_parens.dart.intertwined.expect
@@ -37,36 +37,35 @@
                       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([)
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4_with_parens.dart.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4_with_parens.dart.expect
index 71e11d0..caeb4d4 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4_with_parens.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4_with_parens.dart.expect
@@ -10,19 +10,21 @@
       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(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4_with_parens.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4_with_parens.dart.intertwined.expect
index b3d8ee3..21506db 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4_with_parens.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4_with_parens.dart.intertwined.expect
@@ -37,48 +37,46 @@
                       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)
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5_with_parens.dart.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5_with_parens.dart.expect
index 4f4a015..d3fba8e 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5_with_parens.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5_with_parens.dart.expect
@@ -10,25 +10,28 @@
       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(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5_with_parens.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5_with_parens.dart.intertwined.expect
index 2b8b343..0a48a26 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5_with_parens.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5_with_parens.dart.intertwined.expect
@@ -37,73 +37,70 @@
                       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(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(.)
-                                                                        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(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(.)
+                                                            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)
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6_with_parens.dart.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6_with_parens.dart.expect
index 5555c17..64b976b 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6_with_parens.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6_with_parens.dart.expect
@@ -10,27 +10,31 @@
       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(()
-        handleIdentifier(arg, expression)
-        handleNoTypeArguments(])
-        handleNoArguments(])
-        handleSend(arg, ])
-        handleIndexedExpression(null, [, ])
-        handleParenthesizedExpression(()
-        handleNonNullAssertExpression(!)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            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(])
+            handleSend(arg, ])
+            handleIndexedExpression(null, [, ])
+          endParenthesizedExpression(()
+          handleNonNullAssertExpression(!)
+        endParenthesizedExpression(()
         handleIdentifier(arg2, expression)
         handleNoTypeArguments(])
         handleNoArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6_with_parens.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6_with_parens.dart.intertwined.expect
index 71a5e93..53e472d 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6_with_parens.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6_with_parens.dart.intertwined.expect
@@ -37,84 +37,80 @@
                       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(()
+                            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)
+                                                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
+                                                                  parseParenthesizedExpressionOrRecordLiteral(()
+                                                                    listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                                     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(.)
+                                                                            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(()
-                                                        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(()
+                                                                    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)
+                                                      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)
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex_with_parens.dart.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex_with_parens.dart.expect
index e8062f8..5f54d7f 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex_with_parens.dart.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex_with_parens.dart.expect
@@ -10,12 +10,13 @@
       endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
       handleAsyncModifier(null, null)
       beginBlockFunctionBody({)
-        handleIdentifier(obj, expression)
-        handleNoTypeArguments(!)
-        handleNoArguments(!)
-        handleSend(obj, !)
-        handleNonNullAssertExpression(!)
-        handleParenthesizedExpression(()
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(obj, expression)
+          handleNoTypeArguments(!)
+          handleNoArguments(!)
+          handleSend(obj, !)
+          handleNonNullAssertExpression(!)
+        endParenthesizedExpression(()
         handleIdentifier(arg, expression)
         handleNoTypeArguments(])
         handleNoArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex_with_parens.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex_with_parens.dart.intertwined.expect
index 60e3550f..ea8920e 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex_with_parens.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex_with_parens.dart.intertwined.expect
@@ -37,26 +37,25 @@
                       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(()
+                            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)
diff --git a/pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method.dart.expect b/pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method.dart.expect
index 6d8f5ab..3128078 100644
--- a/pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method.dart.expect
+++ b/pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method.dart.expect
@@ -130,14 +130,15 @@
         handleSend(print, ;)
         handleExpressionStatement(;)
         beginIfStatement(if)
-          handleIdentifier(foo, expression)
-          handleNoTypeArguments(>>)
-          handleNoArguments(>>)
-          handleSend(foo, >>)
-          handleRecoverableError(Message[ExperimentNotEnabled, This requires the 'triple-shift' language feature to be enabled., Try updating your pubspec.yaml to set the minimum SDK constraint to 2.14 or higher, and running 'pub get'., {string: triple-shift, string2: 2.14}], >>, >=)
-          handleLiteralInt(42)
-          handleAssignmentExpression(>>>=)
-          handleParenthesizedExpression(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleIdentifier(foo, expression)
+            handleNoTypeArguments(>>)
+            handleNoArguments(>>)
+            handleSend(foo, >>)
+            handleRecoverableError(Message[ExperimentNotEnabled, This requires the 'triple-shift' language feature to be enabled., Try updating your pubspec.yaml to set the minimum SDK constraint to 2.14 or higher, and running 'pub get'., {string: triple-shift, string2: 2.14}], >>, >=)
+            handleLiteralInt(42)
+            handleAssignmentExpression(>>>=)
+          endParenthesizedExpression(()
           beginBinaryExpression(==)
             handleIdentifier(foo, expression)
             handleNoTypeArguments())
diff --git a/pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method.dart.intertwined.expect b/pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method.dart.intertwined.expect
index 980cb19..655103c 100644
--- a/pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method.dart.intertwined.expect
@@ -284,34 +284,33 @@
                       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, >>)
-                                        reportRecoverableErrorWithEnd(>>, >=, Message[ExperimentNotEnabled, This requires the 'triple-shift' language feature to be enabled., Try updating your pubspec.yaml to set the minimum SDK constraint to 2.14 or higher, and running 'pub get'., {string: triple-shift, string2: 2.14}])
-                                          listener: handleRecoverableError(Message[ExperimentNotEnabled, This requires the 'triple-shift' language feature to be enabled., Try updating your pubspec.yaml to set the minimum SDK constraint to 2.14 or higher, and running 'pub get'., {string: triple-shift, string2: 2.14}], >>, >=)
-                                        rewriter()
-                                        parsePrecedenceExpression(>>>=, 1, true)
-                                          parseUnaryExpression(>>>=, true)
-                                            parsePrimary(>>>=, expression)
-                                              parseLiteralInt(>>>=)
-                                                listener: handleLiteralInt(42)
-                                        listener: handleAssignmentExpression(>>>=)
-                                    ensureCloseParen(42, ()
-                                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, >>)
+                                    reportRecoverableErrorWithEnd(>>, >=, Message[ExperimentNotEnabled, This requires the 'triple-shift' language feature to be enabled., Try updating your pubspec.yaml to set the minimum SDK constraint to 2.14 or higher, and running 'pub get'., {string: triple-shift, string2: 2.14}])
+                                      listener: handleRecoverableError(Message[ExperimentNotEnabled, This requires the 'triple-shift' language feature to be enabled., Try updating your pubspec.yaml to set the minimum SDK constraint to 2.14 or higher, and running 'pub get'., {string: triple-shift, string2: 2.14}], >>, >=)
+                                    rewriter()
+                                    parsePrecedenceExpression(>>>=, 1, true)
+                                      parseUnaryExpression(>>>=, true)
+                                        parsePrimary(>>>=, expression)
+                                          parseLiteralInt(>>>=)
+                                            listener: handleLiteralInt(42)
+                                    listener: handleAssignmentExpression(>>>=)
+                                ensureCloseParen(42, ()
+                                listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(==)
                         parsePrecedenceExpression(==, 8, true)
                           parseUnaryExpression(==, true)
diff --git a/pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method_prime.dart.expect b/pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method_prime.dart.expect
index 5b84bd6..8cdcc10 100644
--- a/pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method_prime.dart.expect
+++ b/pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method_prime.dart.expect
@@ -104,13 +104,14 @@
         handleSend(print, ;)
         handleExpressionStatement(;)
         beginIfStatement(if)
-          handleIdentifier(foo, expression)
-          handleNoTypeArguments(>>=)
-          handleNoArguments(>>=)
-          handleSend(foo, >>=)
-          handleLiteralInt(42)
-          handleAssignmentExpression(>>=)
-          handleParenthesizedExpression(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleIdentifier(foo, expression)
+            handleNoTypeArguments(>>=)
+            handleNoArguments(>>=)
+            handleSend(foo, >>=)
+            handleLiteralInt(42)
+            handleAssignmentExpression(>>=)
+          endParenthesizedExpression(()
           beginBinaryExpression(==)
             handleIdentifier(foo, expression)
             handleNoTypeArguments())
diff --git a/pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method_prime.dart.intertwined.expect
index 13d82fc..e226427 100644
--- a/pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method_prime.dart.intertwined.expect
@@ -272,31 +272,30 @@
                       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, >>=)
-                                        parsePrecedenceExpression(>>=, 1, true)
-                                          parseUnaryExpression(>>=, true)
-                                            parsePrimary(>>=, expression)
-                                              parseLiteralInt(>>=)
-                                                listener: handleLiteralInt(42)
-                                        listener: handleAssignmentExpression(>>=)
-                                    ensureCloseParen(42, ()
-                                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, >>=)
+                                    parsePrecedenceExpression(>>=, 1, true)
+                                      parseUnaryExpression(>>=, true)
+                                        parsePrimary(>>=, expression)
+                                          parseLiteralInt(>>=)
+                                            listener: handleLiteralInt(42)
+                                    listener: handleAssignmentExpression(>>=)
+                                ensureCloseParen(42, ()
+                                listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(==)
                         parsePrecedenceExpression(==, 8, true)
                           parseUnaryExpression(==, true)
diff --git a/pkg/front_end/parser_testcases/no-triple-shift/triple_shift_not_triple_shift.dart.expect b/pkg/front_end/parser_testcases/no-triple-shift/triple_shift_not_triple_shift.dart.expect
index 9e599ba..f5521fe 100644
--- a/pkg/front_end/parser_testcases/no-triple-shift/triple_shift_not_triple_shift.dart.expect
+++ b/pkg/front_end/parser_testcases/no-triple-shift/triple_shift_not_triple_shift.dart.expect
@@ -80,8 +80,9 @@
             handleOperator(>>)
           endLiteralSymbol(#, 1)
           beginBinaryExpression(>)
-            handleLiteralInt(2)
-            handleParenthesizedExpression(()
+            beginParenthesizedExpressionOrRecordLiteral(()
+              handleLiteralInt(2)
+            endParenthesizedExpression(()
           endBinaryExpression(>)
         endArguments(1, (, ))
         handleSend(print, ;)
diff --git a/pkg/front_end/parser_testcases/no-triple-shift/triple_shift_not_triple_shift.dart.intertwined.expect b/pkg/front_end/parser_testcases/no-triple-shift/triple_shift_not_triple_shift.dart.intertwined.expect
index d3f42a9..04b1a46 100644
--- a/pkg/front_end/parser_testcases/no-triple-shift/triple_shift_not_triple_shift.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/no-triple-shift/triple_shift_not_triple_shift.dart.intertwined.expect
@@ -180,18 +180,17 @@
                                         parsePrecedenceExpression(>, 9, 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(1, (, ))
                               listener: handleSend(print, ;)
diff --git a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional.dart.expect b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional.dart.expect
index ba8a1cc..bd40051 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional.dart.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional.dart.expect
@@ -144,21 +144,23 @@
         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, {, })
diff --git a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional.dart.intertwined.expect
index ea5feb9..15b1d71 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional.dart.intertwined.expect
@@ -540,64 +540,62 @@
                           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(;)
diff --git a/pkg/front_end/parser_testcases/record/record_literal_01.dart b/pkg/front_end/parser_testcases/record/record_literal_01.dart
new file mode 100644
index 0000000..f32a178
--- /dev/null
+++ b/pkg/front_end/parser_testcases/record/record_literal_01.dart
@@ -0,0 +1,3 @@
+void foo() {
+  var record = (1, 2, a: 3, b: 4);
+}
diff --git a/pkg/front_end/parser_testcases/record/record_literal_01.dart.expect b/pkg/front_end/parser_testcases/record/record_literal_01.dart.expect
new file mode 100644
index 0000000..8e0987f
--- /dev/null
+++ b/pkg/front_end/parser_testcases/record/record_literal_01.dart.expect
@@ -0,0 +1,36 @@
+beginCompilationUnit(void)
+  beginMetadataStar(void)
+  endMetadataStar(0)
+  beginTopLevelMember(void)
+    beginTopLevelMethod(, null, null)
+      handleVoidKeyword(void)
+      handleIdentifier(foo, topLevelFunctionDeclaration)
+      handleNoTypeVariables(()
+      beginFormalParameters((, MemberKind.TopLevelMethod)
+      endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
+      handleAsyncModifier(null, null)
+      beginBlockFunctionBody({)
+        beginMetadataStar(var)
+        endMetadataStar(0)
+        handleNoType(var)
+        beginVariablesDeclaration(record, null, var)
+          handleIdentifier(record, localVariableDeclaration)
+          beginInitializedIdentifier(record)
+            beginVariableInitializer(=)
+              beginParenthesizedExpressionOrRecordLiteral(()
+                handleLiteralInt(1)
+                handleLiteralInt(2)
+                handleIdentifier(a, namedRecordFieldReference)
+                handleLiteralInt(3)
+                handleNamedRecordField(:)
+                handleIdentifier(b, namedRecordFieldReference)
+                handleLiteralInt(4)
+                handleNamedRecordField(:)
+              endRecordLiteral((, 4)
+            endVariableInitializer(=)
+          endInitializedIdentifier(record)
+        endVariablesDeclaration(1, ;)
+      endBlockFunctionBody(1, {, })
+    endTopLevelMethod(void, null, })
+  endTopLevelDeclaration()
+endCompilationUnit(1, )
diff --git a/pkg/front_end/parser_testcases/record/record_literal_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/record_literal_01.dart.intertwined.expect
new file mode 100644
index 0000000..bce8911
--- /dev/null
+++ b/pkg/front_end/parser_testcases/record/record_literal_01.dart.intertwined.expect
@@ -0,0 +1,92 @@
+parseUnit(void)
+  skipErrorTokens(void)
+  listener: beginCompilationUnit(void)
+  syntheticPreviousToken(void)
+  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
+    parseMetadataStar()
+      listener: beginMetadataStar(void)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl()
+      listener: beginTopLevelMember(void)
+      parseTopLevelMethod(, null, null, , Instance of 'VoidType', null, foo, false)
+        listener: beginTopLevelMethod(, null, null)
+        listener: handleVoidKeyword(void)
+        ensureIdentifierPotentiallyRecovered(void, topLevelFunctionDeclaration, false)
+          listener: handleIdentifier(foo, topLevelFunctionDeclaration)
+        parseMethodTypeVar(foo)
+          listener: handleNoTypeVariables(()
+        parseGetterOrFormalParameters(foo, foo, false, MemberKind.TopLevelMethod)
+          parseFormalParameters(foo, MemberKind.TopLevelMethod)
+            parseFormalParametersRest((, MemberKind.TopLevelMethod)
+              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
+              listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
+        parseAsyncModifierOpt())
+          listener: handleAsyncModifier(null, null)
+          inPlainSync()
+        parseFunctionBody(), false, false)
+          listener: beginBlockFunctionBody({)
+          notEofOrValue(}, var)
+          parseStatement({)
+            parseStatementX({)
+              parseExpressionStatementOrDeclarationAfterModifiers(var, {, null, var, null, false)
+                looksLikeLocalFunction(record)
+                listener: beginMetadataStar(var)
+                listener: endMetadataStar(0)
+                listener: handleNoType(var)
+                listener: beginVariablesDeclaration(record, null, var)
+                parseVariablesDeclarationRest(var, true)
+                  parseOptionallyInitializedIdentifier(var)
+                    ensureIdentifier(var, localVariableDeclaration)
+                      listener: handleIdentifier(record, localVariableDeclaration)
+                    listener: beginInitializedIdentifier(record)
+                    parseVariableInitializerOpt(record)
+                      listener: beginVariableInitializer(=)
+                      parseExpression(=)
+                        parsePrecedenceExpression(=, 1, true)
+                          parseUnaryExpression(=, true)
+                            parsePrimary(=, expression)
+                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                                parseParenthesizedExpressionOrRecordLiteral(=)
+                                  listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                  parseExpression(()
+                                    parsePrecedenceExpression((, 1, true)
+                                      parseUnaryExpression((, true)
+                                        parsePrimary((, expression)
+                                          parseLiteralInt(()
+                                            listener: handleLiteralInt(1)
+                                  parseExpression(,)
+                                    parsePrecedenceExpression(,, 1, true)
+                                      parseUnaryExpression(,, true)
+                                        parsePrimary(,, expression)
+                                          parseLiteralInt(,)
+                                            listener: handleLiteralInt(2)
+                                  ensureIdentifier(,, namedRecordFieldReference)
+                                    listener: handleIdentifier(a, namedRecordFieldReference)
+                                  parseExpression(:)
+                                    parsePrecedenceExpression(:, 1, true)
+                                      parseUnaryExpression(:, true)
+                                        parsePrimary(:, expression)
+                                          parseLiteralInt(:)
+                                            listener: handleLiteralInt(3)
+                                  listener: handleNamedRecordField(:)
+                                  ensureIdentifier(,, namedRecordFieldReference)
+                                    listener: handleIdentifier(b, namedRecordFieldReference)
+                                  parseExpression(:)
+                                    parsePrecedenceExpression(:, 1, true)
+                                      parseUnaryExpression(:, true)
+                                        parsePrimary(:, expression)
+                                          parseLiteralInt(:)
+                                            listener: handleLiteralInt(4)
+                                  listener: handleNamedRecordField(:)
+                                  ensureCloseParen(4, ()
+                                  listener: endRecordLiteral((, 4)
+                      listener: endVariableInitializer(=)
+                    listener: endInitializedIdentifier(record)
+                  ensureSemicolon())
+                  listener: endVariablesDeclaration(1, ;)
+          notEofOrValue(}, })
+          listener: endBlockFunctionBody(1, {, })
+        listener: endTopLevelMethod(void, null, })
+  listener: endTopLevelDeclaration()
+  reportAllErrorTokens(void)
+  listener: endCompilationUnit(1, )
diff --git a/pkg/front_end/parser_testcases/record/record_literal_01.dart.parser.expect b/pkg/front_end/parser_testcases/record/record_literal_01.dart.parser.expect
new file mode 100644
index 0000000..500ce14
--- /dev/null
+++ b/pkg/front_end/parser_testcases/record/record_literal_01.dart.parser.expect
@@ -0,0 +1,9 @@
+void foo() {
+var record = (1, 2, a: 3, b: 4);
+}
+
+
+void[KeywordToken] foo[StringToken]([BeginToken])[SimpleToken] {[BeginToken]
+var[KeywordToken] record[StringToken] =[SimpleToken] ([BeginToken]1[StringToken],[SimpleToken] 2[StringToken],[SimpleToken] a[StringToken]:[SimpleToken] 3[StringToken],[SimpleToken] b[StringToken]:[SimpleToken] 4[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+[SimpleToken]
diff --git a/pkg/front_end/parser_testcases/record/record_literal_01.dart.scanner.expect b/pkg/front_end/parser_testcases/record/record_literal_01.dart.scanner.expect
new file mode 100644
index 0000000..500ce14
--- /dev/null
+++ b/pkg/front_end/parser_testcases/record/record_literal_01.dart.scanner.expect
@@ -0,0 +1,9 @@
+void foo() {
+var record = (1, 2, a: 3, b: 4);
+}
+
+
+void[KeywordToken] foo[StringToken]([BeginToken])[SimpleToken] {[BeginToken]
+var[KeywordToken] record[StringToken] =[SimpleToken] ([BeginToken]1[StringToken],[SimpleToken] 2[StringToken],[SimpleToken] a[StringToken]:[SimpleToken] 3[StringToken],[SimpleToken] b[StringToken]:[SimpleToken] 4[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+[SimpleToken]
diff --git a/pkg/front_end/parser_testcases/record/record_literal_02.dart b/pkg/front_end/parser_testcases/record/record_literal_02.dart
new file mode 100644
index 0000000..0751484
--- /dev/null
+++ b/pkg/front_end/parser_testcases/record/record_literal_02.dart
@@ -0,0 +1,11 @@
+void foo() {
+  // With ending comma.
+  (42, 42, 42, );
+  (foo: 42, bar: 42, 42, baz: 42, );
+
+  // Nested.
+  ((42, 42), 42);
+
+  // With function inside.
+  ((foo, bar) => 42, 42);
+}
diff --git a/pkg/front_end/parser_testcases/record/record_literal_02.dart.expect b/pkg/front_end/parser_testcases/record/record_literal_02.dart.expect
new file mode 100644
index 0000000..30f102a
--- /dev/null
+++ b/pkg/front_end/parser_testcases/record/record_literal_02.dart.expect
@@ -0,0 +1,69 @@
+beginCompilationUnit(void)
+  beginMetadataStar(void)
+  endMetadataStar(0)
+  beginTopLevelMember(void)
+    beginTopLevelMethod(, null, null)
+      handleVoidKeyword(void)
+      handleIdentifier(foo, topLevelFunctionDeclaration)
+      handleNoTypeVariables(()
+      beginFormalParameters((, MemberKind.TopLevelMethod)
+      endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
+      handleAsyncModifier(null, null)
+      beginBlockFunctionBody({)
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleLiteralInt(42)
+          handleLiteralInt(42)
+          handleLiteralInt(42)
+        endRecordLiteral((, 3)
+        handleExpressionStatement(;)
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleIdentifier(foo, namedRecordFieldReference)
+          handleLiteralInt(42)
+          handleNamedRecordField(:)
+          handleIdentifier(bar, namedRecordFieldReference)
+          handleLiteralInt(42)
+          handleNamedRecordField(:)
+          handleLiteralInt(42)
+          handleIdentifier(baz, namedRecordFieldReference)
+          handleLiteralInt(42)
+          handleNamedRecordField(:)
+        endRecordLiteral((, 4)
+        handleExpressionStatement(;)
+        beginParenthesizedExpressionOrRecordLiteral(()
+          beginParenthesizedExpressionOrRecordLiteral(()
+            handleLiteralInt(42)
+            handleLiteralInt(42)
+          endRecordLiteral((, 2)
+          handleLiteralInt(42)
+        endRecordLiteral((, 2)
+        handleExpressionStatement(;)
+        beginParenthesizedExpressionOrRecordLiteral(()
+          handleNoTypeVariables(()
+          beginFunctionExpression(()
+            beginFormalParameters((, MemberKind.Local)
+              beginMetadataStar(foo)
+              endMetadataStar(0)
+              beginFormalParameter(foo, MemberKind.Local, null, null, null)
+                handleNoType(()
+                handleIdentifier(foo, formalParameterDeclaration)
+                handleFormalParameterWithoutValue(,)
+              endFormalParameter(null, null, null, foo, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
+              beginMetadataStar(bar)
+              endMetadataStar(0)
+              beginFormalParameter(bar, MemberKind.Local, null, null, null)
+                handleNoType(,)
+                handleIdentifier(bar, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, null, bar, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
+            endFormalParameters(2, (, ), MemberKind.Local)
+            handleAsyncModifier(null, null)
+            handleLiteralInt(42)
+            handleExpressionFunctionBody(=>, null)
+          endFunctionExpression((, ,)
+          handleLiteralInt(42)
+        endRecordLiteral((, 2)
+        handleExpressionStatement(;)
+      endBlockFunctionBody(4, {, })
+    endTopLevelMethod(void, null, })
+  endTopLevelDeclaration()
+endCompilationUnit(1, )
diff --git a/pkg/front_end/parser_testcases/record/record_literal_02.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/record_literal_02.dart.intertwined.expect
new file mode 100644
index 0000000..a44d3f8f
--- /dev/null
+++ b/pkg/front_end/parser_testcases/record/record_literal_02.dart.intertwined.expect
@@ -0,0 +1,236 @@
+parseUnit(void)
+  skipErrorTokens(void)
+  listener: beginCompilationUnit(void)
+  syntheticPreviousToken(void)
+  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
+    parseMetadataStar()
+      listener: beginMetadataStar(void)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl()
+      listener: beginTopLevelMember(void)
+      parseTopLevelMethod(, null, null, , Instance of 'VoidType', null, foo, false)
+        listener: beginTopLevelMethod(, null, null)
+        listener: handleVoidKeyword(void)
+        ensureIdentifierPotentiallyRecovered(void, topLevelFunctionDeclaration, false)
+          listener: handleIdentifier(foo, topLevelFunctionDeclaration)
+        parseMethodTypeVar(foo)
+          listener: handleNoTypeVariables(()
+        parseGetterOrFormalParameters(foo, foo, false, MemberKind.TopLevelMethod)
+          parseFormalParameters(foo, MemberKind.TopLevelMethod)
+            parseFormalParametersRest((, MemberKind.TopLevelMethod)
+              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
+              listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
+        parseAsyncModifierOpt())
+          listener: handleAsyncModifier(null, null)
+          inPlainSync()
+        parseFunctionBody(), false, false)
+          listener: beginBlockFunctionBody({)
+          notEofOrValue(}, ()
+          parseStatement({)
+            parseStatementX({)
+              parseExpressionStatementOrDeclaration({, false)
+                parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
+                  looksLikeLocalFunction(()
+                  parseExpressionStatement({)
+                    parseExpression({)
+                      parsePrecedenceExpression({, 1, true)
+                        parseUnaryExpression({, true)
+                          parsePrimary({, expression)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
+                              parseParenthesizedExpressionOrRecordLiteral({)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseLiteralInt(()
+                                          listener: handleLiteralInt(42)
+                                parseExpression(,)
+                                  parsePrecedenceExpression(,, 1, true)
+                                    parseUnaryExpression(,, true)
+                                      parsePrimary(,, expression)
+                                        parseLiteralInt(,)
+                                          listener: handleLiteralInt(42)
+                                parseExpression(,)
+                                  parsePrecedenceExpression(,, 1, true)
+                                    parseUnaryExpression(,, true)
+                                      parsePrimary(,, expression)
+                                        parseLiteralInt(,)
+                                          listener: handleLiteralInt(42)
+                                ensureCloseParen(,, ()
+                                listener: endRecordLiteral((, 3)
+                    ensureSemicolon())
+                    listener: handleExpressionStatement(;)
+          notEofOrValue(}, ()
+          parseStatement(;)
+            parseStatementX(;)
+              parseExpressionStatementOrDeclaration(;, false)
+                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                  looksLikeLocalFunction(()
+                  parseExpressionStatement(;)
+                    parseExpression(;)
+                      parsePrecedenceExpression(;, 1, true)
+                        parseUnaryExpression(;, true)
+                          parsePrimary(;, expression)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                              parseParenthesizedExpressionOrRecordLiteral(;)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                ensureIdentifier((, namedRecordFieldReference)
+                                  listener: handleIdentifier(foo, namedRecordFieldReference)
+                                parseExpression(:)
+                                  parsePrecedenceExpression(:, 1, true)
+                                    parseUnaryExpression(:, true)
+                                      parsePrimary(:, expression)
+                                        parseLiteralInt(:)
+                                          listener: handleLiteralInt(42)
+                                listener: handleNamedRecordField(:)
+                                ensureIdentifier(,, namedRecordFieldReference)
+                                  listener: handleIdentifier(bar, namedRecordFieldReference)
+                                parseExpression(:)
+                                  parsePrecedenceExpression(:, 1, true)
+                                    parseUnaryExpression(:, true)
+                                      parsePrimary(:, expression)
+                                        parseLiteralInt(:)
+                                          listener: handleLiteralInt(42)
+                                listener: handleNamedRecordField(:)
+                                parseExpression(,)
+                                  parsePrecedenceExpression(,, 1, true)
+                                    parseUnaryExpression(,, true)
+                                      parsePrimary(,, expression)
+                                        parseLiteralInt(,)
+                                          listener: handleLiteralInt(42)
+                                ensureIdentifier(,, namedRecordFieldReference)
+                                  listener: handleIdentifier(baz, namedRecordFieldReference)
+                                parseExpression(:)
+                                  parsePrecedenceExpression(:, 1, true)
+                                    parseUnaryExpression(:, true)
+                                      parsePrimary(:, expression)
+                                        parseLiteralInt(:)
+                                          listener: handleLiteralInt(42)
+                                listener: handleNamedRecordField(:)
+                                ensureCloseParen(,, ()
+                                listener: endRecordLiteral((, 4)
+                    ensureSemicolon())
+                    listener: handleExpressionStatement(;)
+          notEofOrValue(}, ()
+          parseStatement(;)
+            parseStatementX(;)
+              parseExpressionStatementOrDeclaration(;, false)
+                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                  looksLikeLocalFunction(()
+                  parseExpressionStatement(;)
+                    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)
+                                                    parseLiteralInt(()
+                                                      listener: handleLiteralInt(42)
+                                            parseExpression(,)
+                                              parsePrecedenceExpression(,, 1, true)
+                                                parseUnaryExpression(,, true)
+                                                  parsePrimary(,, expression)
+                                                    parseLiteralInt(,)
+                                                      listener: handleLiteralInt(42)
+                                            ensureCloseParen(42, ()
+                                            listener: endRecordLiteral((, 2)
+                                parseExpression(,)
+                                  parsePrecedenceExpression(,, 1, true)
+                                    parseUnaryExpression(,, true)
+                                      parsePrimary(,, expression)
+                                        parseLiteralInt(,)
+                                          listener: handleLiteralInt(42)
+                                ensureCloseParen(42, ()
+                                listener: endRecordLiteral((, 2)
+                    ensureSemicolon())
+                    listener: handleExpressionStatement(;)
+          notEofOrValue(}, ()
+          parseStatement(;)
+            parseStatementX(;)
+              parseExpressionStatementOrDeclaration(;, false)
+                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                  looksLikeLocalFunction(()
+                  parseExpressionStatement(;)
+                    parseExpression(;)
+                      parsePrecedenceExpression(;, 1, true)
+                        parseUnaryExpression(;, true)
+                          parsePrimary(;, expression)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                              parseParenthesizedExpressionOrRecordLiteral(;)
+                                listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                parseExpression(()
+                                  parsePrecedenceExpression((, 1, true)
+                                    parseUnaryExpression((, true)
+                                      parsePrimary((, expression)
+                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
+                                          listener: handleNoTypeVariables(()
+                                          parseFunctionExpression(()
+                                            listener: beginFunctionExpression(()
+                                            parseFormalParametersRequiredOpt((, MemberKind.Local)
+                                              parseFormalParametersRest((, MemberKind.Local)
+                                                listener: beginFormalParameters((, MemberKind.Local)
+                                                parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.Local)
+                                                  parseMetadataStar(()
+                                                    listener: beginMetadataStar(foo)
+                                                    listener: endMetadataStar(0)
+                                                  listener: beginFormalParameter(foo, MemberKind.Local, null, null, null)
+                                                  listener: handleNoType(()
+                                                  ensureIdentifier((, formalParameterDeclaration)
+                                                    listener: handleIdentifier(foo, formalParameterDeclaration)
+                                                  listener: handleFormalParameterWithoutValue(,)
+                                                  listener: endFormalParameter(null, null, null, foo, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
+                                                parseFormalParameter(,, FormalParameterKind.requiredPositional, MemberKind.Local)
+                                                  parseMetadataStar(,)
+                                                    listener: beginMetadataStar(bar)
+                                                    listener: endMetadataStar(0)
+                                                  listener: beginFormalParameter(bar, MemberKind.Local, null, null, null)
+                                                  listener: handleNoType(,)
+                                                  ensureIdentifier(,, formalParameterDeclaration)
+                                                    listener: handleIdentifier(bar, formalParameterDeclaration)
+                                                  listener: handleFormalParameterWithoutValue())
+                                                  listener: endFormalParameter(null, null, null, bar, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
+                                                listener: endFormalParameters(2, (, ), MemberKind.Local)
+                                            parseAsyncOptBody(), true, false)
+                                              parseAsyncModifierOpt())
+                                                listener: handleAsyncModifier(null, null)
+                                                inPlainSync()
+                                              parseFunctionBody(), true, false)
+                                                parseExpressionFunctionBody(=>, true)
+                                                  parseExpression(=>)
+                                                    parsePrecedenceExpression(=>, 1, true)
+                                                      parseUnaryExpression(=>, true)
+                                                        parsePrimary(=>, expression)
+                                                          parseLiteralInt(=>)
+                                                            listener: handleLiteralInt(42)
+                                                  listener: handleExpressionFunctionBody(=>, null)
+                                                  inGenerator()
+                                            listener: endFunctionExpression((, ,)
+                                parseExpression(,)
+                                  parsePrecedenceExpression(,, 1, true)
+                                    parseUnaryExpression(,, true)
+                                      parsePrimary(,, expression)
+                                        parseLiteralInt(,)
+                                          listener: handleLiteralInt(42)
+                                ensureCloseParen(42, ()
+                                listener: endRecordLiteral((, 2)
+                    ensureSemicolon())
+                    listener: handleExpressionStatement(;)
+          notEofOrValue(}, })
+          listener: endBlockFunctionBody(4, {, })
+        listener: endTopLevelMethod(void, null, })
+  listener: endTopLevelDeclaration()
+  reportAllErrorTokens(void)
+  listener: endCompilationUnit(1, )
diff --git a/pkg/front_end/parser_testcases/record/record_literal_02.dart.parser.expect b/pkg/front_end/parser_testcases/record/record_literal_02.dart.parser.expect
new file mode 100644
index 0000000..05e0c83
--- /dev/null
+++ b/pkg/front_end/parser_testcases/record/record_literal_02.dart.parser.expect
@@ -0,0 +1,25 @@
+void foo() {
+
+(42, 42, 42, );
+(foo: 42, bar: 42, 42, baz: 42, );
+
+
+((42, 42), 42);
+
+
+((foo, bar) => 42, 42);
+}
+
+
+void[KeywordToken] foo[StringToken]([BeginToken])[SimpleToken] {[BeginToken]
+
+([BeginToken]42[StringToken],[SimpleToken] 42[StringToken],[SimpleToken] 42[StringToken],[SimpleToken] )[SimpleToken];[SimpleToken]
+([BeginToken]foo[StringToken]:[SimpleToken] 42[StringToken],[SimpleToken] bar[StringToken]:[SimpleToken] 42[StringToken],[SimpleToken] 42[StringToken],[SimpleToken] baz[StringToken]:[SimpleToken] 42[StringToken],[SimpleToken] )[SimpleToken];[SimpleToken]
+
+
+([BeginToken]([BeginToken]42[StringToken],[SimpleToken] 42[StringToken])[SimpleToken],[SimpleToken] 42[StringToken])[SimpleToken];[SimpleToken]
+
+
+([BeginToken]([BeginToken]foo[StringToken],[SimpleToken] bar[StringToken])[SimpleToken] =>[SimpleToken] 42[StringToken],[SimpleToken] 42[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+[SimpleToken]
diff --git a/pkg/front_end/parser_testcases/record/record_literal_02.dart.scanner.expect b/pkg/front_end/parser_testcases/record/record_literal_02.dart.scanner.expect
new file mode 100644
index 0000000..05e0c83
--- /dev/null
+++ b/pkg/front_end/parser_testcases/record/record_literal_02.dart.scanner.expect
@@ -0,0 +1,25 @@
+void foo() {
+
+(42, 42, 42, );
+(foo: 42, bar: 42, 42, baz: 42, );
+
+
+((42, 42), 42);
+
+
+((foo, bar) => 42, 42);
+}
+
+
+void[KeywordToken] foo[StringToken]([BeginToken])[SimpleToken] {[BeginToken]
+
+([BeginToken]42[StringToken],[SimpleToken] 42[StringToken],[SimpleToken] 42[StringToken],[SimpleToken] )[SimpleToken];[SimpleToken]
+([BeginToken]foo[StringToken]:[SimpleToken] 42[StringToken],[SimpleToken] bar[StringToken]:[SimpleToken] 42[StringToken],[SimpleToken] 42[StringToken],[SimpleToken] baz[StringToken]:[SimpleToken] 42[StringToken],[SimpleToken] )[SimpleToken];[SimpleToken]
+
+
+([BeginToken]([BeginToken]42[StringToken],[SimpleToken] 42[StringToken])[SimpleToken],[SimpleToken] 42[StringToken])[SimpleToken];[SimpleToken]
+
+
+([BeginToken]([BeginToken]foo[StringToken],[SimpleToken] bar[StringToken])[SimpleToken] =>[SimpleToken] 42[StringToken],[SimpleToken] 42[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+[SimpleToken]
diff --git a/pkg/front_end/test/parser_equivalence_suite.dart b/pkg/front_end/test/parser_equivalence_suite.dart
index b35a7b3..712e512 100644
--- a/pkg/front_end/test/parser_equivalence_suite.dart
+++ b/pkg/front_end/test/parser_equivalence_suite.dart
@@ -118,7 +118,7 @@
         bIndex++;
       }
       if (anyIgnored) continue;
-      if (aLine != bLine) {
+      if (aLine.trim() != bLine.trim()) {
         return "Disagreement: '${aLine}' vs '${bLine}'";
       }
       aIndex++;
diff --git a/pkg/front_end/test/parser_test_listener.dart b/pkg/front_end/test/parser_test_listener.dart
index 70eba07..c1f95bd 100644
--- a/pkg/front_end/test/parser_test_listener.dart
+++ b/pkg/front_end/test/parser_test_listener.dart
@@ -2452,6 +2452,12 @@
   }
 
   @override
+  void handleNamedRecordField(Token colon) {
+    seen(colon);
+    doPrint('handleNamedRecordField(' '$colon)');
+  }
+
+  @override
   void beginNewExpression(Token token) {
     seen(token);
     doPrint('beginNewExpression(' '$token)');
@@ -2529,9 +2535,24 @@
   }
 
   @override
-  void handleParenthesizedExpression(Token token) {
+  void beginParenthesizedExpressionOrRecordLiteral(Token token) {
     seen(token);
-    doPrint('handleParenthesizedExpression(' '$token)');
+    doPrint('beginParenthesizedExpressionOrRecordLiteral(' '$token)');
+    indent++;
+  }
+
+  @override
+  void endRecordLiteral(Token token, int count) {
+    indent--;
+    seen(token);
+    doPrint('endRecordLiteral(' '$token, ' '$count)');
+  }
+
+  @override
+  void endParenthesizedExpression(Token token) {
+    indent--;
+    seen(token);
+    doPrint('endParenthesizedExpression(' '$token)');
   }
 
   @override
diff --git a/pkg/front_end/test/parser_test_parser.dart b/pkg/front_end/test/parser_test_parser.dart
index 91a7954..097a722 100644
--- a/pkg/front_end/test/parser_test_parser.dart
+++ b/pkg/front_end/test/parser_test_parser.dart
@@ -1558,10 +1558,13 @@
   }
 
   @override
-  Token parseParenthesizedExpressionOrFunctionLiteral(Token token) {
-    doPrint('parseParenthesizedExpressionOrFunctionLiteral(' '$token)');
+  Token parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(
+      Token token) {
+    doPrint('parseParenthesizedExpressionFunctionLiteralOrRecordLiteral('
+        '$token)');
     indent++;
-    var result = super.parseParenthesizedExpressionOrFunctionLiteral(token);
+    var result =
+        super.parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(token);
     indent--;
     return result;
   }
@@ -1576,19 +1579,10 @@
   }
 
   @override
-  Token parseParenthesizedExpression(Token token) {
-    doPrint('parseParenthesizedExpression(' '$token)');
+  Token parseParenthesizedExpressionOrRecordLiteral(Token token) {
+    doPrint('parseParenthesizedExpressionOrRecordLiteral(' '$token)');
     indent++;
-    var result = super.parseParenthesizedExpression(token);
-    indent--;
-    return result;
-  }
-
-  @override
-  Token parseExpressionInParenthesis(Token token) {
-    doPrint('parseExpressionInParenthesis(' '$token)');
-    indent++;
-    var result = super.parseExpressionInParenthesis(token);
+    var result = super.parseParenthesizedExpressionOrRecordLiteral(token);
     indent--;
     return result;
   }
diff --git a/pkg/front_end/test/spell_checking_list_code.txt b/pkg/front_end/test/spell_checking_list_code.txt
index f8727e4..8c0102f 100644
--- a/pkg/front_end/test/spell_checking_list_code.txt
+++ b/pkg/front_end/test/spell_checking_list_code.txt
@@ -499,6 +499,7 @@
 fileuri
 finally's
 finv
+fire
 firsts
 fishy
 fishythefish
@@ -927,6 +928,7 @@
 paren
 parens
 parenteses
+parity
 particularly
 partof
 patchup
diff --git a/tests/language/record_literal_test.dart b/tests/language/record_literal_test.dart
new file mode 100644
index 0000000..3e17480
--- /dev/null
+++ b/tests/language/record_literal_test.dart
@@ -0,0 +1,40 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+main() {
+  var record1 = (1, 2, a: 3, b: 4);
+  //            ^
+  // [analyzer] SYNTACTIC_ERROR.EXPERIMENT_NOT_ENABLED
+  // [cfe] This requires the 'records' language feature to be enabled.
+  print(record1);
+
+  // With ending comma.
+  var record2 = (42, 42, 42, );
+  //            ^
+  // [analyzer] SYNTACTIC_ERROR.EXPERIMENT_NOT_ENABLED
+  // [cfe] This requires the 'records' language feature to be enabled.
+  print(record2);
+  var record3 = (foo: 42, bar: 42, 42, baz: 42, );
+  //            ^
+  // [analyzer] SYNTACTIC_ERROR.EXPERIMENT_NOT_ENABLED
+  // [cfe] This requires the 'records' language feature to be enabled.
+  print(record3);
+
+  // Nested.
+  var record4 = ((42, 42), 42);
+  //            ^
+  // [analyzer] SYNTACTIC_ERROR.EXPERIMENT_NOT_ENABLED
+  // [cfe] This requires the 'records' language feature to be enabled.
+  //             ^
+  // [analyzer] SYNTACTIC_ERROR.EXPERIMENT_NOT_ENABLED
+  // [cfe] This requires the 'records' language feature to be enabled.
+  print(record4);
+
+  // With function inside.
+  var record5 = ((foo, bar) => 42, 42);
+  //            ^
+  // [analyzer] SYNTACTIC_ERROR.EXPERIMENT_NOT_ENABLED
+  // [cfe] This requires the 'records' language feature to be enabled.
+  print(record5);
+}
diff --git a/tests/language_2/record_literal_test.dart b/tests/language_2/record_literal_test.dart
new file mode 100644
index 0000000..9c35f3b
--- /dev/null
+++ b/tests/language_2/record_literal_test.dart
@@ -0,0 +1,42 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// @dart = 2.9
+
+main() {
+  var record1 = (1, 2, a: 3, b: 4);
+  //            ^
+  // [analyzer] SYNTACTIC_ERROR.EXPERIMENT_NOT_ENABLED
+  // [cfe] This requires the 'records' language feature to be enabled.
+  print(record1);
+
+  // With ending comma.
+  var record2 = (42, 42, 42, );
+  //            ^
+  // [analyzer] SYNTACTIC_ERROR.EXPERIMENT_NOT_ENABLED
+  // [cfe] This requires the 'records' language feature to be enabled.
+  print(record2);
+  var record3 = (foo: 42, bar: 42, 42, baz: 42, );
+  //            ^
+  // [analyzer] SYNTACTIC_ERROR.EXPERIMENT_NOT_ENABLED
+  // [cfe] This requires the 'records' language feature to be enabled.
+  print(record3);
+
+  // Nested.
+  var record4 = ((42, 42), 42);
+  //            ^
+  // [analyzer] SYNTACTIC_ERROR.EXPERIMENT_NOT_ENABLED
+  // [cfe] This requires the 'records' language feature to be enabled.
+  //             ^
+  // [analyzer] SYNTACTIC_ERROR.EXPERIMENT_NOT_ENABLED
+  // [cfe] This requires the 'records' language feature to be enabled.
+  print(record4);
+
+  // With function inside.
+  var record5 = ((foo, bar) => 42, 42);
+  //            ^
+  // [analyzer] SYNTACTIC_ERROR.EXPERIMENT_NOT_ENABLED
+  // [cfe] This requires the 'records' language feature to be enabled.
+  print(record5);
+}
diff --git a/tools/experimental_features.yaml b/tools/experimental_features.yaml
index 2a869d1..ec7842a 100644
--- a/tools/experimental_features.yaml
+++ b/tools/experimental_features.yaml
@@ -16,6 +16,10 @@
 # analyzer:
 #   dart pkg/analyzer/tool/experiments/generate.dart
 #
+# Also, pkg/analyzer/lib/src/dart/analysis/driver.dart will need a bump in
+# DATA_VERSION if making changes that changes previous flags' "index", e.g.
+# if adding a new flag that doesn't happen to be lexicographically last.
+#
 # kernel:
 #   pkg/front_end/tool/fasta generate-experimental-flags
 #
@@ -124,6 +128,9 @@
   inference-update-2:
     help: "Type promotion for fields"
 
+  records:
+    help: "Records"
+
 # Experiment flag only used for testing.
   test-experiment:
     help: >-